public void Navigate(NavigationTarget navTarget, INavigationParams navParams = null) { switch (navTarget) { case NavigationTarget.HomeLogin: DismissViewController(false, () => LaunchHomePage()); break; case NavigationTarget.Login: if (navParams is LoginNavigationParams loginParams) { DismissViewController(false, () => LaunchLoginFlow(loginParams.Email)); } else { DismissViewController(false, () => LaunchLoginFlow()); } break; case NavigationTarget.Lock: DismissViewController(false, () => PerformSegue("lockPasswordSegue", this)); break; case NavigationTarget.AutofillCiphers: case NavigationTarget.Home: DismissViewController(false, () => PerformSegue("loginListSegue", this)); break; } }
public void JumpToAddress(NavigationTarget target, uint address, bool isCurrentStatement) { switch (target) { case NavigationTarget.Code: { this.CodeTool.Show(this.Window.DockPanel); this.CodeTool.BringToFront(); this.CodeTool.Activate(); this.CodeTool.SetAddress(address, isCurrentStatement); this.CallstackTool.RefreshCallstack(); this.ThreadsTool.RefreshThreads(); } break; case NavigationTarget.Memory: { } break; case NavigationTarget.Log: { } break; } }
public void Start() { _mesh = GetComponent<TextMesh>(); NavigationTargetRig tRig = transform.parent.GetComponent<NavigationTargetRig>(); _target = tRig.Target; _missionAccomplished = false; }
public void CustomNavigationAttribute_NavigationEnum_ReturnAttributeValues(NavigationTarget navigation, string expectedCopy, string expectedUrl) { var actual = navigation.GetContent(); actual.Content.Should().Be(expectedCopy); actual.Url.Should().Be(expectedUrl); }
private void OnNav(NavigationTarget target) { CurrentTab = target; switch (target) { case NavigationTarget.Student: _studentViewModel.LoadStudents(); CurrentViewModel = _studentViewModel; break; case NavigationTarget.Grade: _gradeViewModel.LoadGrades(); CurrentViewModel = _gradeViewModel; break; case NavigationTarget.Chart: CurrentViewModel = _chartViewModel; break; case NavigationTarget.Test: _testViewModel.LoadTests(); CurrentViewModel = _testViewModel; break; case NavigationTarget.Settings: CurrentViewModel = _settingsViewModel; break; default: CurrentViewModel = _testViewModel; break; } }
public EnterPasswordViewModel(NavigationStateViewModel navigationState, NavigationTarget navigationTarget, string subtitle) : base(navigationState, navigationTarget) { Subtitle = subtitle; // This means pressing continue will make the password empty string. // pressing cancel will return null. _password = ""; this.ValidateProperty(x => x.Password, ValidatePassword); this.ValidateProperty(x => x.ConfirmPassword, ValidateConfirmPassword); var backCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler); var nextCommandCanExecute = this.WhenAnyValue( x => x.IsDialogOpen, x => x.Password, x => x.ConfirmPassword, (isDialogOpen, password, confirmPassword) => { // This will fire validations before return canExecute value. this.RaisePropertyChanged(nameof(Password)); this.RaisePropertyChanged(nameof(ConfirmPassword)); return(isDialogOpen && ((string.IsNullOrEmpty(password) && string.IsNullOrEmpty(confirmPassword)) || (!string.IsNullOrEmpty(password) && !string.IsNullOrEmpty(confirmPassword) && !Validations.Any))); }) .ObserveOn(RxApp.MainThreadScheduler); var cancelCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler); BackCommand = ReactiveCommand.Create(() => Close(), backCommandCanExecute); NextCommand = ReactiveCommand.Create(() => Close(Password), nextCommandCanExecute); CancelCommand = ReactiveCommand.Create(() => Close(), cancelCommandCanExecute); }
private void NavigateStartToACO() { if (m_startToACOPath != null && m_startToACOPath.Count > 0 && m_startToACONavInfo != null) { NavigateGeneric(m_startToACONavInfo.TargetNode); /// Check if agent reached next route node float nextNodeDistance = Vector3.Distance(transform.position, m_startToACONavInfo.TargetNode.transform.position); if (nextNodeDistance < DESTINATION_TOLERANCE) { /// Increment target index m_startToACONavInfo.TargetIndex += 1; /// Check if index is more or equal to path length if (m_startToACONavInfo.TargetIndex >= m_startToACOPath.Count) { /// Set drive path to ACO, the next path m_currentDrivePathTarget = NavigationTarget.ACO; Debug.Log($"Agent '{this.gameObject.name}' completed A* Navigation. Proceeding with ACO path..."); } else { /// Set next to node if inside range Connection nextConn = m_startToACOPath[m_startToACONavInfo.TargetIndex]; OnTravelNewConnection?.Invoke(this, nextConn); m_startToACONavInfo.TargetNode = nextConn.ToNode; } } } }
private void NavigateACOToStart() { if (m_acoToStartPath != null && m_acoToStartPath.Count > 0 && m_acoToStartNavInfo != null) { NavigateGeneric(m_acoToStartNavInfo.TargetNode); /// Check if agent reached next route node float nextNodeDistance = Vector3.Distance(transform.position, m_acoToStartNavInfo.TargetNode.transform.position); if (nextNodeDistance < DESTINATION_TOLERANCE) { /// Increment target index m_acoToStartNavInfo.TargetIndex += 1; /// Check if index is more or equal to path length if (m_acoToStartNavInfo.TargetIndex >= m_acoToStartPath.Count) { /// Finished all paths, reset and sleep m_currentDrivePathTarget = NavigationTarget.None; m_ui.SetStatusText("Finished and returned home. Sleeping (zzz)"); Debug.Log($"Agent '{this.gameObject.name}' finished ACO path, duration of '{m_totalDuration}s'"); ResetPath(); } else { /// Set next to node if inside range Connection nextConn = m_acoToStartPath[m_acoToStartNavInfo.TargetIndex]; OnTravelNewConnection?.Invoke(this, nextConn); m_acoToStartNavInfo.TargetNode = nextConn.ToNode; } } } }
/// <summary> /// Navigate to a specified target /// </summary> /// <param name="target">The specified target</param> public void NavigateToTarget(NavigationTarget target) { Button[] pathButtons = GetParentPathButtons(target); for (var i = 0; i < pathButtons.Length; i++) { //JazzMessageBox.LoadingMask.WaitLoading(); //JazzMessageBox.LoadingMask.WaitSubMaskLoading(); pathButtons[i].Click(); //JazzMessageBox.LoadingMask.WaitLoading(); //JazzMessageBox.LoadingMask.WaitSubMaskLoading(); TimeManager.MediumPause(); } if (JazzMessageBox.MessageBox.Exists()) { if (JazzMessageBox.MessageBox.GetMessage().Contains("服务器错误") || JazzMessageBox.MessageBox.GetMessage().Contains("Server error")) { JazzMessageBox.MessageBox.OK(); } } TimeManager.MediumPause(); }
public void ShowJumpToAddressDialog(NavigationTarget target) { _jumpToAddressDialog.Target = target; if (_jumpToAddressDialog.ShowDialog(this.Window) == System.Windows.Forms.DialogResult.OK) { this.JumpToAddress(target, _jumpToAddressDialog.Address, false); } }
/// <summary> /// Generates a Windows Phone Path Url to the target you want to navigate to /// </summary> /// <param name="target">The target to navigate to</param> /// <param name="queryParams">Optional extra query string params.</param> /// <returns>A string representation of the path</returns> public static string GenerateNavigateUrl(NavigationTarget target, Dictionary <string, string> queryParams = null) { string path; switch (target) { case NavigationTarget.Loading: path = "/Pages/Authed/Loading.xaml"; break; case NavigationTarget.Capture: path = "/Pages/Authed/Capture.xaml"; break; case NavigationTarget.Messages: path = "/Pages/Authed/Messages.xaml"; break; case NavigationTarget.Settings: path = "/Pages/Authed/Settings.xaml"; break; case NavigationTarget.Friends: path = "/Pages/Authed/Friends.xaml"; break; case NavigationTarget.FriendInfo: path = "/Pages/Authed/FriendsPages/Info.xaml"; break; case NavigationTarget.Login: default: path = "/Pages/Login.xaml"; break; } if (queryParams == null) { return(path); } bool first = true; foreach (var queryParam in queryParams) { if (first) { path += string.Format("?{0}={1}", queryParam.Key, HttpUtility.HtmlEncode(queryParam.Value)); } else { path += string.Format("&{0}={1}", queryParam.Key, HttpUtility.HtmlEncode(queryParam.Value)); } first = false; } return(path); }
protected DialogViewModelBase(NavigationStateViewModel navigationState, NavigationTarget navigationTarget) : base(navigationState, navigationTarget) { _currentTaskCompletionSource = new TaskCompletionSource <TResult>(); _disposable = this.WhenAnyValue(x => x.IsDialogOpen) .Skip(1) // Skip the initial value change (which is false). .DistinctUntilChanged() .Subscribe(OnIsDialogOpenChanged); }
/// <summary> /// Handles the NavigateTarget event raised by the view model to navigate to an open document. /// </summary> /// <param name="sender">The view model.</param> /// <param name="e">Navigation target.</param> protected void NavigateTarget(object sender, NavigationTarget e) { if (e == null) { throw new ArgumentNullException(nameof(e)); } ViewContext.NavigationManager.NavigateDocumentRegion(e.NavigationId); }
protected RoutableViewModel(NavigationStateViewModel navigationState, NavigationTarget navigationTarget) { NavigationState = navigationState; NavigationTarget = navigationTarget; BackCommand = ReactiveCommand.Create(() => GoBack()); CancelCommand = ReactiveCommand.Create(() => ClearNavigation()); }
/// <summary> /// Navigates to the specified path, and removes the backstack /// </summary> /// <param name="target">The target to navigate to.</param> /// <param name="queryParams">Optional extra query string params.</param> public static void NavigateToAndRemoveBackStack(NavigationTarget target, Dictionary <string, string> queryParams = null) { if (queryParams == null) { queryParams = new Dictionary <string, string>(); } queryParams.Add("removeBackStack", "true"); NavigateTo(GenerateNavigateUrl(target, queryParams)); }
private void NavigateTo(object sender, ExecutedRoutedEventArgs e) { NavigationTarget target = e.Parameter as NavigationTarget; if (target == null) { return; } UxTabSet.SelectedItem = UxLookupTab; UxLookupPanel.NavigateTo(target.WordName); }
private void AppendWord(FlowDocument document, WordInfo word) { ArticleParser parser = new ArticleParser(); WordArticle article = parser.Parse(word.Word.Name, word.Word.Description); Paragraph paragraph = FlowDocumentStyles.CreateParagraph(); document.Blocks.Add(paragraph); IEnumerable <WordFormGroup> formGroups = article.FormGroups.Where(fg => fg.TranslationGroups.SelectMany(tg => tg.Translations).Contains(Translation)); foreach (WordFormGroup formGroup in formGroups) { bool firstForm = true; foreach (string form in formGroup.Forms) { Hyperlink link = new Hyperlink(); link.Command = Commands.NavigateTo; link.CommandParameter = NavigationTarget.ToWord(word.Word.Name); paragraph.Inlines.Add(link); Run run = new Run(form); link.Inlines.Add(run); if (firstForm) { FlowDocumentStyles.FormatWord(run); firstForm = false; } else { FlowDocumentStyles.FormatWordForm(run); } paragraph.Inlines.Add(new LineBreak()); } foreach (WordTranslationGroup translationGroup in formGroup.TranslationGroups.Where(tg => tg.Translations.Contains(Translation))) { foreach (string translation in translationGroup.Translations) { Run run = new Run("\u2022 " + translation); paragraph.Inlines.Add(run); FlowDocumentStyles.FormatTranslation(run); paragraph.Inlines.Add(new LineBreak()); } foreach (string example in translationGroup.Examples) { Run run = new Run("Example: " + example); paragraph.Inlines.Add(run); FlowDocumentStyles.FormatExample(run); paragraph.Inlines.Add(new LineBreak()); } } } }
public void NavigatioTarget_ValidDocumentId_PropertyDocumentIdReturnsSameObject() { // Arrange DocumentId documentId = DocumentId.CreateNewId(ProjectId.CreateNewId()); int position = 42; DocumentId actualResult; DocumentId expectedResult = documentId; // Act actualResult = new NavigationTarget(documentId, position).DocumentId; // Assert actualResult.Should().BeSameAs(expectedResult); }
protected override async Task <IEnumerable <CodeActionOperation> > ComputeOperationsAsync(CancellationToken cancellationToken) { var operations = new List <CodeActionOperation>(); Solution changedSolution = await this.codeChangeOperation(cancellationToken); NavigationTarget navigationTarget = await this.navigationTargetCalculation(changedSolution, cancellationToken); operations.Add(new ApplyChangesOperation(changedSolution)); if (navigationTarget != null) { operations.Add(new DocumentNavigationOperation(navigationTarget.DocumentId, navigationTarget.Position)); } return(operations); }
public TestDialogViewModel(NavigationStateViewModel navigationState, NavigationTarget navigationTarget, string message) : base(navigationState, navigationTarget) { _message = message; var backCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler); var cancelCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler); var nextCommandCanExecute = this.WhenAnyValue(x => x.IsDialogOpen).ObserveOn(RxApp.MainThreadScheduler); BackCommand = ReactiveCommand.Create(() => GoBack(), backCommandCanExecute); CancelCommand = ReactiveCommand.Create(() => Close(false), cancelCommandCanExecute); NextCommand = ReactiveCommand.Create(() => Close(true), nextCommandCanExecute); }
public DialogScreenViewModel(NavigationTarget navigationTarget = NavigationTarget.DialogScreen) : base(navigationTarget) { this.WhenAnyValue(x => x.IsDialogOpen) .Skip(1) // Skip the initial value change (which is false). .DistinctUntilChanged() .Subscribe( x => { if (!x) { CloseScreen(); } }); }
private void jumpToAddressToolStripMenuItem_Click(object sender, EventArgs e) { NavigationTarget target = NavigationTarget.Memory; if (this.dockPanel.ActiveContent == this.Debugger.MemoryTool) { target = NavigationTarget.Memory; } else if (this.dockPanel.ActiveContent == this.Debugger.CodeTool) { target = NavigationTarget.Code; } this.Debugger.ShowJumpToAddressDialog(target); }
public void NavigatioTarget_ValidPosition_PropertyPositionReturnsSameValue() { // Arrange DocumentId documentId = DocumentId.CreateNewId(ProjectId.CreateNewId()); int position = 42; int actualResult; int expectedResult = position; // Act actualResult = new NavigationTarget(documentId, position).Position; // Assert actualResult.Should().Be(expectedResult); }
/// <summary> /// Generates a Windows Phone Path Url to the target you want to navigate to /// </summary> /// <param name="target">The target to navigate to</param> /// <param name="queryParams">Optional extra query string params.</param> /// <returns>A string representation of the path</returns> public static string GenerateNavigateUrl(NavigationTarget target, Dictionary<string, string> queryParams = null) { string path; switch (target) { case NavigationTarget.Loading: path = "/Pages/Authed/Loading.xaml"; break; case NavigationTarget.Capture: path = "/Pages/Authed/Capture.xaml"; break; case NavigationTarget.Messages: path = "/Pages/Authed/Messages.xaml"; break; case NavigationTarget.Settings: path = "/Pages/Authed/Settings.xaml"; break; case NavigationTarget.Friends: path = "/Pages/Authed/Friends.xaml"; break; case NavigationTarget.FriendInfo: path = "/Pages/Authed/FriendsPages/Info.xaml"; break; case NavigationTarget.Login: default: path = "/Pages/Login.xaml"; break; } if (queryParams == null) return path; bool first = true; foreach (var queryParam in queryParams) { if (first) path += string.Format("?{0}={1}", queryParam.Key, HttpUtility.HtmlEncode(queryParam.Value)); else path += string.Format("&{0}={1}", queryParam.Key, HttpUtility.HtmlEncode(queryParam.Value)); first = false; } return path; }
void InternalNavigate(IRegionNavigationJournalEntry entry, Action <bool> callback) { _navigatingInternal = true; NavigationTarget.Navigate( entry.Uri, nr => { _navigatingInternal = false; if (nr.Result.HasValue) { callback(nr.Result.Value); } }, entry.Args); }
/// <summary> /// Called to publish a new document. Calls the <see cref="Publish"/> /// event which is handled on the <see cref="ViewBase"/>. /// </summary> /// <param name="navigationSettings">Navigation settings for the new document.</param> protected void PublishDocument(NavigationSettings navigationSettings) { var publish = Publish; if (publish != null) { var navigationTarget = new NavigationTarget(navigationId, Title); if (navigationHistory.Count > 0) { navigationTarget.AppendNavigationHistory(navigationHistory.Select(t => t.Target).ToArray()); } navigationSettings.NavigationHistory = navigationTarget.NavigationHistory; publish(this, navigationSettings); } }
private void InternalNavigate(IRegionNavigationJournalEntry entry, Action <bool> callback) { _isNavigatingInternal = true; NavigationTarget.RequestNavigate( entry.Uri, nr => { _isNavigatingInternal = false; if (nr.Result.HasValue) { callback(nr.Result.Value); } }, entry.Parameters); }
/// <summary>Calculates the position, the caret should be set to, after the /// code fix was applied.</summary> /// <param name="changedSolution">The changed solution (code fix applied).</param> /// <param name="originalDocument">The original document (code fix not applied).</param> /// <param name="diagnostic">The diagnosted code fix.</param> /// <param name="cancellationToken">A cancellation token to cancel the calculation.</param> /// <returns>The position , the caret should be set to, after the code fix /// was applied. Null if the caret should not be moved.</returns> private static async Task <NavigationTarget> CalculateNavigationTarget(Solution changedSolution, Document originalDocument, Diagnostic diagnostic, CancellationToken cancellationToken) { MemberDeclarationSyntax originalDeclaration; MemberDeclarationSyntax changedDeclaration; SyntaxNode originalSyntaxRoot; SyntaxNode changedSyntaxRoot; Document changedDocument; int targetPosition; NavigationTarget result = null; // Get syntax root of the original document originalSyntaxRoot = await originalDocument.GetSyntaxRootAsync(cancellationToken) .ConfigureAwait(false); // Get the original declaration that was diagnosted originalDeclaration = originalSyntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start) .Parent .AncestorsAndSelf() .OfType <MemberDeclarationSyntax>() .First(); // Get the changed document changedDocument = changedSolution.GetDocument(originalDocument.Id); // Get syntax root of the changed document changedSyntaxRoot = await changedDocument.GetSyntaxRootAsync(cancellationToken) .ConfigureAwait(false); // Find declaration in changed document changedDeclaration = changedSyntaxRoot.DescendantNodes() .OfType <MemberDeclarationSyntax>() .FirstOrDefault(newNode => SyntaxFactory.AreEquivalent(newNode, originalDeclaration)); // Get the target position in the the XML documentation header of the // changed declaration inside the changed document targetPosition = DocumentationHelper.GetPositionOfFirstEmptyDocumentationTag(changedDeclaration); // targetPosition is less than zero if no empty documentation tag was found. if (targetPosition > 0) { result = new NavigationTarget(changedDocument.Id, targetPosition); } return(result); }
/// <summary> /// Called by Prism when navigating to the current document. /// </summary> /// <param name="navigationContext">The navigation context.</param> public void OnNavigatedTo(NavigationContext navigationContext) { if (navigationContext == null) { throw new ArgumentNullException(nameof(navigationContext)); } if (!String.IsNullOrEmpty(uriQueryString) && uriQueryString.Equals(navigationContext.Uri.OriginalString, StringComparison.OrdinalIgnoreCase)) { return; } uriQueryString = navigationContext.Uri.OriginalString; foreach (KeyValuePair <string, object> parameter in navigationContext.Parameters) { if (parameter.Key.Equals("Title", StringComparison.Ordinal)) { Title = parameter.Value?.ToString(); continue; } if (parameter.Key.Equals("NavigationId", StringComparison.Ordinal)) { NavigationId = parameter.Value?.ToString(); continue; } if (parameter.Key.Equals("Navigation", StringComparison.Ordinal)) { string[] history = NavigationTarget.GetNavigationHistory(parameter.Value?.ToString()); foreach (string target in history) { if (!String.IsNullOrEmpty(target)) { navigationHistory.Add(new NavigationTarget(target)); } } } } RaiseActivation(); }
/// <summary> /// Get the array of locators on path of navigating to the target navigation item. /// </summary> /// <param name="target">The specified navigation target</param> /// <returns>Array of locators on path of navigating to the target navigation item</returns> private Button[] GetParentPathButtons(NavigationTarget target) { List <Button> pathButtons = new List <Button>(); NavigationTarget?currentTarget = target; while (currentTarget.HasValue) { var targetItem = NavigatorItem.NavigationItems[currentTarget.Value]; pathButtons.Add(targetItem.Button); currentTarget = targetItem.Parent; } pathButtons.Reverse(); return(pathButtons.ToArray()); }
public void Navigate(NavigationTarget navTarget, INavigationParams navParams) { switch (navTarget) { case NavigationTarget.HomeLogin: Current.MainPage = new NavigationPage(new HomePage(Options)); break; case NavigationTarget.Login: if (navParams is LoginNavigationParams loginParams) { Current.MainPage = new NavigationPage(new LoginPage(loginParams.Email, Options)); } break; case NavigationTarget.Lock: if (navParams is LockNavigationParams lockParams) { Current.MainPage = new NavigationPage(new LockPage(Options, lockParams.AutoPromptBiometric)); } else { Current.MainPage = new NavigationPage(new LockPage(Options)); } break; case NavigationTarget.Home: Current.MainPage = new TabsPage(Options); break; case NavigationTarget.AddEditCipher: Current.MainPage = new NavigationPage(new AddEditPage(appOptions: Options)); break; case NavigationTarget.AutofillCiphers: Current.MainPage = new NavigationPage(new AutofillCiphersPage(Options)); break; case NavigationTarget.SendAddEdit: Current.MainPage = new NavigationPage(new SendAddEditPage(Options)); break; } }
/// <summary> /// Drives the along a certain connection path /// </summary> /// <param name="startToACOAStarPath">A* path from the agent start to the ACO path</param> /// <param name="acoConnections">The ACO connections path that goal around all goals</param> /// <param name="acoToStartAStarPath">A* path from the final ACO node back to the agent's start path</param> public void SetMovePath(List <Connection> startToACOAStarPath, List <ACOConnection> acoConnections, List <Connection> acoToStartAStarPath) { if (acoConnections == null || acoConnections != null && acoConnections.Count <= 0) { Debug.LogError("Unable to drive along connection path. acoConnections invalid"); return; } /// Set navigation paths for this agent. Contains three paths: /// Agent start to the initial ACO start node /// The Total ACO path /// Final ACO node to the initial Agent start node m_acoConnectionPath = acoConnections; m_startToACOPath = startToACOAStarPath; m_acoToStartPath = acoToStartAStarPath; /// Set Move states to go from Start to the ACO start m_currentDrivePathTarget = NavigationTarget.StartToACO; /// Set movement vars to default values m_currentTargetACOConnIndex = 0; m_currentACOConnRouteIndex = 0; m_currentTargetACOConn = m_acoConnectionPath[m_currentTargetACOConnIndex]; /// Set NavigateInfo for each A* path m_startToACONavInfo = new NavigateToInfo { TargetNode = m_startToACOPath.FirstOrDefault().ToNode, TargetIndex = 0 }; m_acoToStartNavInfo = new NavigateToInfo { TargetNode = m_acoToStartPath.FirstOrDefault().ToNode, TargetIndex = 0, }; /// Set start position for agent this.transform.position = startToACOAStarPath.FirstOrDefault().FromNode.transform.position; Debug.Log($"Agent '{this.name}' path set! Start to ACO '{m_startToACOPath.Count}' Waypoints, ACO Total '{m_acoConnectionPath.Count}' waypoints, ACO to Start '{m_acoToStartPath.Count}' waypoints"); m_ui.SetStatusText($"New Path: Moving to '{m_acoConnectionPath[m_acoConnectionPath.Count - 1].ToNode.name}'"); }
public void JumpToAddress( NavigationTarget target, uint address, bool isCurrentStatement ) { switch( target ) { case NavigationTarget.Code: { this.CodeTool.Show( this.Window.DockPanel ); this.CodeTool.BringToFront(); this.CodeTool.Activate(); this.CodeTool.SetAddress( address, isCurrentStatement ); this.CallstackTool.RefreshCallstack(); this.ThreadsTool.RefreshThreads(); } break; case NavigationTarget.Memory: { } break; case NavigationTarget.Log: { } break; } }
protected abstract void Navigate(Route route, NavigationTarget target, string uri);
public void ShowJumpToAddressDialog( NavigationTarget target ) { _jumpToAddressDialog.Target = target; if( _jumpToAddressDialog.ShowDialog( this.Window ) == System.Windows.Forms.DialogResult.OK ) this.JumpToAddress( target, _jumpToAddressDialog.Address, false ); }
/// <summary> /// Navigates to the specified path /// </summary> /// <param name="target">The target to navigate to.</param> /// <param name="queryParams">Optional extra query string params.</param> public static void NavigateTo(NavigationTarget target, Dictionary<string, string> queryParams = null) { NavigateTo(GenerateNavigateUrl(target, queryParams)); }
/// <summary> /// Navigates to the specified path, and removes the backstack /// </summary> /// <param name="target">The target to navigate to.</param> /// <param name="queryParams">Optional extra query string params.</param> public static void NavigateToAndRemoveBackStack(NavigationTarget target, Dictionary<string, string> queryParams = null) { if (queryParams == null) queryParams = new Dictionary<string, string>(); queryParams.Add("removeBackStack", "true"); NavigateTo(GenerateNavigateUrl(target, queryParams)); }
/// <summary> /// Generates a Windows Phone Path Uri to the target you want to navigate to /// </summary> /// <param name="target">The target to navigate to</param> /// <returns>A Uri representation of the path</returns> public static Uri GenerateNavigateUri(NavigationTarget target) { return new Uri(GenerateNavigateUrl(target), UriKind.Relative); }
public void Navigate(NavigationTarget target) { var route = Router.Current.FindRoute(target); var url = Router.Current.CreateUrl(target); Navigate(route, target, url); }