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