public void DisplayViewInSplitPanel(string url, NavigationParameters parameter)
{
Action operation = () =>
{
var uri = new Uri(url, UriKind.Relative);
_loadedEdgePanel = (FrameworkElement)Application.LoadComponent(uri);
_loadedEdgePanel.Loaded += (sender, evt) => SplitterPanelLoaded(sender, evt, parameter);
_splitWindowContent.Children.Clear();
var contains = _splitWindowContent.Children.Contains(_loadedEdgePanel);
_splitWindowContent.Children.Add(_loadedEdgePanel);
// Force the metro window to calculate the size of the user control.
_loadedEdgePanel.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
_splitWindowContent.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
_splitWindow.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
DisplayEdgePanel();
};
if (_isEdgePanelOpen)
{
HideEdgePanel(operation);
}
else
{
operation();
}
}
public override void OnNavigatedFrom(NavigationParameters parameters)
{
Loader.CancelLoading();
ListLoader.CancelLoading();
base.OnNavigatedFrom(parameters);
}
void Navigate()
{
NavigationParameters parameters = new NavigationParameters();
parameters.Add("message", "Message from MainPage");
_navigationService.Navigate("ViewA", parameters);
}
private void SaveCustomerDetails()
{
if (_currentCustomer != null)
{
NavigationParameters navigationParameters = new NavigationParameters();
if (_currentCustomer.Id == default(int))
{
//_currentCustomer.CustomerTypeId = _currentCustomerType.Id;
_clientLayer.AddCustomer(_currentCustomer);
navigationParameters.Add("StatusCustomer", "NewCustomer");
}
else
{
_clientLayer.UpdateCustomer(_currentCustomer);
navigationParameters.Add("StatusCustomer", "UpdateCustomer");
}
RaiseNotification();
_regionManager.RequestNavigate(RegionNames.MainRegion, ViewNames.CustomerListView, navigationParameters);
navigationParameters.Add("CurrentCustomer", _currentCustomer);
_regionManager.RequestNavigate(RegionNames.DetailRegion, ViewNames.CustomerDetailsView, navigationParameters);
//_regionManager.RequestNavigate(RegionNames.MainRegion, new Uri(ViewNames.CustomerListView, UriKind.Relative), navigationParameters);
}
else
{
}
}
private void Navigate()
{
var navParams = new NavigationParameters();
navParams.Add("timestamp", DateTime.Now);
_navigationService.Navigate("ViewB", navParams);
}
public async Task Init(NavigationParameters parameters)
{
bool successful = await SafeOperation(
TaskEx.Run(async () => Sponsor = await _campService.GetSponsor(parameters.Id)));
FinishedLoading(successful);
}
/// <summary>
/// Initiates navigation to the target specified by the <paramref name="target"/>.
/// </summary>
/// <param name="navigation">The navigation object.</param>
/// <param name="target">A Uri that represents the target where the region will navigate.</param>
/// <param name="navigationParameters">An instance of NavigationParameters, which holds a collection of object parameters.</param>
public static void RequestNavigate(this INavigateAsync navigation, Uri target, NavigationParameters navigationParameters)
{
if (navigation == null)
throw new ArgumentNullException(nameof(navigation));
navigation.RequestNavigate(target, nr => { }, navigationParameters);
}
/// <summary>
/// Initializes a new instance of the <see cref="NavigationContext"/> class for a region name and a
/// <see cref="Uri"/>.
/// </summary>
/// <param name="navigationService">The navigation service.</param>
/// <param name="navigationParameters">The navigation parameters.</param>
/// <param name="uri">The Uri.</param>
public NavigationContext(IRegionNavigationService navigationService, Uri uri, NavigationParameters navigationParameters)
{
NavigationService = navigationService;
Uri = uri;
Parameters = uri != null ? UriParsingHelper.ParseQuery(uri) : null;
GetNavigationParameters(navigationParameters);
}
/// <summary>
/// Navigates to the most recent entry in the back navigation history by popping the calling Page off the navigation stack.
/// </summary>
/// <param name="parameters">The navigation parameters</param>
/// <param name="useModalNavigation">If <c>true</c> uses PopModalAsync, if <c>false</c> uses PopAsync</param>
/// <param name="animated">If <c>true</c> the transition is animated, if <c>false</c> there is no animation on transition.</param>
/// <returns>If <c>true</c> a go back operation was successful. If <c>false</c> the go back operation failed.</returns>
public virtual async Task<bool> GoBackAsync(NavigationParameters parameters = null, bool? useModalNavigation = null, bool animated = true)
{
try
{
var page = GetCurrentPage();
var segmentParameters = GetSegmentParameters(null, parameters);
var canNavigate = await CanNavigateAsync(page, segmentParameters);
if (!canNavigate)
return false;
bool useModalForDoPop = UseModalNavigation(page, useModalNavigation);
Page previousPage = GetOnNavigatedToTarget(page, useModalForDoPop);
OnNavigatedFrom(page, segmentParameters);
var poppedPage = await DoPop(page.Navigation, useModalForDoPop, animated);
if (poppedPage != null)
{
OnNavigatedTo(previousPage, segmentParameters);
return true;
}
}
catch (Exception e)
{
_logger.Log(e.ToString(), Category.Exception, Priority.High);
return false;
}
return false;
}
public void OnNavigatedTo(NavigationParameters parameters)
{
Debug.WriteLine("-------------MainPageViewModel----------OnNavigatedTo <--");
if (parameters.ContainsKey("title"))
Title = (string)parameters["title"] + " and Prism";
}
/// <summary>
/// Initiates navigation to the target specified by the <paramref name="target"/>.
/// </summary>
/// <param name="navigation">The navigation object.</param>
/// <param name="target">A string that represents the target where the region will navigate.</param>
/// <param name="navigationParameters">An instance of NavigationParameters, which holds a collection of object parameters.</param>
public static void RequestNavigate(this INavigateAsync navigation, string target, NavigationParameters navigationParameters)
{
if (navigation == null) throw new ArgumentNullException("navigation");
if (target == null) throw new ArgumentNullException("target");
navigation.RequestNavigate(new Uri(target, UriKind.RelativeOrAbsolute), nr => { }, navigationParameters);
}
public override void OnNavigatedTo(NavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
Issue = new IssueViewModel(parameters[Constants.IssueParameterName] as IIssue);
_repo = parameters[Constants.RepoParameterName] as IRepo;
Title = string.Format(LogWork.IssueTitle, Issue.Number);
}
public void WhenGivenDuplicateParametersThrowsArgumentException()
{
Assert.Throws<ArgumentException>(() =>
{
var parameters = new NavigationParameters(_uri);
parameters.Add("id", 3);
});
}
public void AddCustomerHandler()
{
var q = new NavigationParameters();
q.Add("id",-1);
regionManager.RequestNavigate(RegionNames.MainRegion, "CustomerAddUpdateView" + q.ToString());
}
public void OnNavigatedTo(NavigationParameters parameters)
{
if (parameters == null)
return;
var selectedItemName = (string)parameters["selectedItem"];
SelectedPage = Pages.Where(p => p.Name == selectedItemName).FirstOrDefault();
}
/// <summary>
/// Initiates navigation to the target specified by the <paramref name="target"/>.
/// </summary>
/// <param name="navigation">The navigation object.</param>
/// <param name="target">The navigation target</param>
/// <param name="navigationCallback">The callback executed when the navigation request is completed.</param>
/// <param name="navigationParameters">An instance of NavigationParameters, which holds a collection of object parameters.</param>
public static void RequestNavigate(this INavigateAsync navigation, string target, Action<NavigationResult> navigationCallback, NavigationParameters navigationParameters)
{
if (navigation == null) throw new ArgumentNullException("navigation");
if (target == null) throw new ArgumentNullException("target");
var targetUri = new Uri(target, UriKind.RelativeOrAbsolute);
navigation.RequestNavigate(targetUri, navigationCallback, navigationParameters);
}
public bool CanNavigate(NavigationParameters parameters)
{
OnConfirmNavigationCalled = true;
if (parameters.ContainsKey("canNavigate"))
return (bool)parameters["canNavigate"];
return true;
}
public void ParametersParsedFromQueryWithNoQuestionMarkDelimiter()
{
var parameters = new NavigationParameters(_uriWithNoQuestionMarkDelimiter);
Assert.Equal(2, parameters.Count);
Assert.True(parameters.ContainsKey("id"));
Assert.Equal("3", parameters["id"]);
Assert.True(parameters.ContainsKey("name"));
Assert.Equal("brian", parameters["name"]);
}
public override async void OnNavigatedTo(NavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
_repo = parameters[Constants.RepoParameterName] as IRepo;
Title = _repo.Name;
await LoadIssuesAsync(Loader);
}
private void Click()
{
var parameters = new NavigationParameters();
parameters.Add("Message", "A message from ViewA");
//uses the overload to navigate using a class as the key
//when navigating within a NavigationPage, set useModalNavigation = false
NavigationService.Navigate<ViewCViewModel>(parameters);
}
void EditUserRole()
{
var selection = SelectedItems.Select(x => x.Id.ToString(CultureInfo.InvariantCulture));
var sb = new StringBuilder();
sb.Append(UmsViews.EditUserRoleView);
var query = new NavigationParameters {{"Selection", string.Join(",", selection)}};
sb.Append(query);
_regionManager.RequestNavigate(Regions.TagModulesRegion, new Uri(sb.ToString(), UriKind.Relative));
}
public void Edit()
{
if (SelectedCustomer != null )
{
var q = new NavigationParameters();
q.Add("id", SelectedCustomer.CustomerID.ToString());
regionManager.RequestNavigate(RegionNames.MainRegion, "CustomerAddUpdateView" + q.ToString());
//regionManager.RegisterViewWithRegion(RegionNames.MainRegion, typeof(CustomerAddUpdateView));
}
}
void Navigate()
{
NavigationParameters parameters = new NavigationParameters();
parameters.Add("message", "Message from MainPage");
_navigationService.Navigate("ViewA", parameters);
//other ways of navigating depending on how you registered your views for navigation
//_navigationService.Navigate("A", parameters);
//_navigationService.Navigate<ViewAViewModel>(parameters);
}
public override async void OnNavigatedTo(NavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
_issue = parameters[Constants.IssueParameterName] as IIssue;
_repo = parameters[Constants.RepoParameterName] as IRepo;
Title = string.Format(Resources.Strings.WorkLogs.IssueTitle, _issue?.Number);
await LoadWorkLogsAsync(Loader);
}
/// <summary>
/// Called when a feed item is selected.
/// </summary>
/// <param name="selectedFeedItem">The selected feed item.</param>
protected override void OnSelectedFeedItem(FeedItemViewModel selectedFeedItem)
{
var navigationParameters = new NavigationParameters();
navigationParameters.Add("SelectedFeedItem", selectedFeedItem);
var regionManager = ServiceLocator.Current.GetInstance<IRegionManager>();
regionManager.RequestNavigate(
RegionNames.RSSFeedReader,
new Uri(typeof(LabsFeedReaderView).Name, UriKind.Relative),
navigationParameters);
}
protected ApplicationPolicy ApplicationPolicyFromNavigationParameters(NavigationParameters param)
{
var appGuid = param.GetAppPolicyName();
var appPolicy = _AppPolicyManager.FromAppGuid(appGuid);
if (appPolicy == null)
{
throw new Exception("not exists ApplicationPolicy. app name is " + appGuid);
}
return appPolicy;
}
public Task<bool> CanNavigateAsync(NavigationParameters parameters)
{
return Task.Run(() =>
{
OnConfirmNavigationCalled = true;
if (parameters.ContainsKey("canNavigate"))
return (bool)parameters["canNavigate"];
return true;
});
}
private void Address()
{
var navigationParameters = new NavigationParameters();
var data = employeeService.GetAll();
navigationParameters.Add("DataToDisplay", data.GetHashCode().ToString());
AppParameters.Save(data.GetHashCode(), data);
navigationParameters.Add("ReportPath", @"Reports\EmployeeAddressBook.rdlc");
//navigationParameters.Add("Parameters",);
navigationParameters.Add("ReportDataSourceName", "EmployeeAddressBook");
this.regionManager.RequestNavigate(RegionNames.WorkingArea,
new Uri("ReportWindowView" + navigationParameters.ToString(), UriKind.Relative));
}
/// <summary>
/// Navigates the specified region manager to the main view of a specified Prism module.
/// </summary>
/// <param name="regionManager">The region manager that this extension method effects.</param>
/// <param name="regionName">The name of the region to call Navigate on.</param>
/// <param name="moduleName">The name of the module to display.</param>
/// <param name="parameters">The navigation parameters.</param>
public static void RequestNavigateToModuleSpecificView(this IRegionManager regionManager, string regionName, string moduleName, Dictionary<string, string> parameters)
{
if (String.IsNullOrWhiteSpace(moduleName))
throw new ArgumentException(StevenVolckaert.Properties.Resources.ValueNullEmptyOrWhiteSpace, "moduleName");
var navigationParameters = new NavigationParameters();
if (parameters != null && parameters.Count > 0)
foreach (KeyValuePair<string, string> parameter in parameters)
navigationParameters.Add(parameter.Key, parameter.Value);
var uri = new Uri("/" + moduleName.Replace("Module", "View") + navigationParameters, UriKind.Relative);
regionManager.RequestNavigate(regionName, uri);
}
private void OpenMeetingEmail(Meeting meeting)
{
// todo: 12 - Opening an email
//
// This view initiates navigation using the RegionManager.
// The RegionManager will find the region and delegate the
// navigation request to the region specified.
//
// This navigation request also includes additional navigation context, an 'EmailId', to
// allow the Email view to orient to the right item.
var parameters = new NavigationParameters();
parameters.Add(EmailIdName, meeting.EmailId.ToString(GuidNumericFormatSpecifier));
this.regionManager.RequestNavigate(RegionNames.MainContentRegion, new Uri(EmailViewName + parameters, UriKind.Relative));
}
public void OnNavigatingTo(NavigationParameters parameters)
{
}
public void OnNavigatingTo(NavigationParameters parameters)
{
//throw new NotImplementedException();
}
public void OnNavigatingTo(NavigationParameters parameters)
{
Debug.WriteLine($"**** {this.GetType().Name}.{nameof(OnNavigatingTo)}");
}
public void RequestNavigate(System.Uri target, System.Action <NavigationResult> navigationCallback, NavigationParameters navigationParameters)
{
throw new System.NotImplementedException();
}
public override void OnNavigatedTo(NavigationParameters parameters)
{
MenuList = new ObservableCollection <Core.Models.MenuItem>(DataService.GetMenuList());
}
public async Task InitializeForMasterDetailAsync <TViewModelMasterDetail, TViewModelDetail>(NavigationParameters parameters = null) where TViewModelMasterDetail : BaseViewModel
where TViewModelDetail : BaseViewModel
{
await InternalInitializeMasterDetailPage(parameters, typeof(TViewModelMasterDetail), typeof(TViewModelDetail));
}
public HasNavigationParameterMapItem(MapItem mapItem, NavigationParameters navigationParameters) : base(mapItem)
{
NavigationParameters = navigationParameters;
}
public async Task NavigateMenuItemAsync <TViewModelMasterDetail>(Model.MasterDetail.MenuItem selectedMenuItem, NavigationParameters parameters = null) where TViewModelMasterDetail : BaseViewModel
{
await InternalNavigateMenuItemAsync(typeof(TViewModelMasterDetail), selectedMenuItem, parameters);
}
public override void OnNavigatedFrom(NavigationParameters parameters)
{
//if(MovieItem == null)
MovieItem = (DetailedMovie)parameters["movie"];
}
public Task <bool> CanNavigateAsync(NavigationParameters parameters)
{
return(Task.FromResult(true));
}
public async void OnNavigatedTo(NavigationParameters parameters)
{
await 系統初始化();
}
public async Task InitializeAsync <TViewModel>(NavigationParameters parameters = null, bool navigationPage = false, NavigationPage customNavigationPage = null) where TViewModel : BaseViewModel
{
await InternalInitializeAsync(typeof(TViewModel), parameters, navigationPage, customNavigationPage);
}
public async Task InsertBeforeNavigationAsync <TViewModel, TViewModelBefore>(NavigationParameters parameters = null) where TViewModel : BaseViewModel
where TViewModelBefore : BaseViewModel
{
await InternalInsertBeforeNavigationAsync(typeof(TViewModel), typeof(TViewModelBefore), parameters);
}
public void OnNavigatedFrom(NavigationParameters parameters)
{
_eventAggregator.GetEvent <CalculationInputUpdated>().Publish(CalculationInput);
}
public async Task ReplaceNewChildTabbedPageToAsync <TViewModel>(int indexPage = 0, NavigationParameters parameters = null) where TViewModel : BaseViewModel
{
await InternalReplaceNewChildTabbedPageToAsync(indexPage, typeof(TViewModel), parameters);
}
public virtual void OnNavigatedTo(NavigationParameters parameters)
{
}
public async Task NavigateTabbedPageToAsync <TViewModel>(NavigationParameters parameters = null) where TViewModel : BaseViewModel
{
await InternalNavigateTabbedPageToAsync(typeof(TViewModel), parameters);
}
public override void OnNavigatedTo(NavigationParameters parameters)
{
}
public async Task NavigatePushPopupAsync <TViewModel>(NavigationParameters parameters) where TViewModel : BaseViewModel
{
await InternalNavigatePushPopupAsync(typeof(TViewModel), parameters);
}
private async Task InternalInsertBeforeNavigationAsync(Type viewModelType, Type viewModelTypeBefore, NavigationParameters parameters)
{
try
{
Page page = await CreateAndBindPage(viewModelType, parameters);
Page pageBefore = await CreateAndBindPage(viewModelTypeBefore, parameters);
if (CurrentApplication.MainPage is NavigationPage currentNavigationPage)
{
if (currentNavigationPage.Navigation.NavigationStack.All(p => p != page))
{
currentNavigationPage.Navigation.InsertPageBefore(page, pageBefore);
await currentNavigationPage.Navigation.PopAsync();
}
}
else
{
CurrentApplication.MainPage = new NavigationPage(page);
}
}
catch (Exception ex)
{
ex.LogException();
}
}
private async Task InternalReplaceNewChildTabbedPageToAsync(int indexPage, Type viewModelType, NavigationParameters parameters = null)
{
try
{
await BeginInvokeOnMainThreadHelper.BeginInvokeOnMainThreadAsync(async() =>
{
if (CurrentApplication.MainPage is NavigationPage navigationPage)
{
if (navigationPage.CurrentPage is TabbedPage currentTabbedPagePage)
{
Type actualPageType = currentTabbedPagePage.Children[indexPage].GetType();
Type newPageType = GetPageTypeForViewModel(viewModelType);
if (!(actualPageType).Equals(newPageType))
{
Page newPage = await CreateAndBindPage(viewModelType, parameters);
BasePage oldPage = currentTabbedPagePage.Children[indexPage] as BasePage;
await Task.Delay(300);
currentTabbedPagePage.Children[indexPage] = newPage;
}
}
}
return(Task.CompletedTask);
});
}
catch (Exception ex)
{
ex.LogException();
}
}
public virtual void OnNavigatedFrom(NavigationParameters parameters)
{
CancelTasks();
}
public bool CanNavigate(NavigationParameters parameters)
{
return(true);
}
public static MapItemBuilder WithNavigationParameters(this MapItemBuilder mapItemBuilder, NavigationParameters navigationParameters)
{
if (mapItemBuilder.SetupActions.Keys.Contains(400))
{
throw new Exception("This Set more than One time");
}
mapItemBuilder.SetupActions.Add(400, item => new HasNavigationParameterMapItem(item, navigationParameters));
return(mapItemBuilder);
}
private async Task <MasterDetailPage> CreateAndBindMasterDetailPage(Type masterDetailViewModelType, Type detailViewModelType, NavigationParameters parameters)
{
try
{
Type pageType = GetPageTypeForViewModel(masterDetailViewModelType);
if (pageType == null)
{
Exception ex = new Exception($"Mapping type for {masterDetailViewModelType} is not a page");
ex.LogException();
throw ex;
}
MasterDetailPage page = ViewModelLocator.Current.Resolve(pageType) as MasterDetailPage;
BaseViewModel viewModel = ViewModelLocator.Current.Resolve(masterDetailViewModelType) as BaseViewModel;
page.BindingContext = viewModel;
page.Master.BindingContext = viewModel;
var newPage = await CreateAndBindPage(detailViewModelType, parameters);
page.Detail = new NavigationPage(newPage);
return(page);
}
catch (Exception)
{
throw;
}
}
public async Task NavigateToAsync(Type viewModelType, NavigationParameters parameters)
{
await InternalNavigateToAsync(viewModelType, parameters);
}
public async void OnNavigatedTo(NavigationParameters parameters)
{
await Task.Delay(100);
}
private async Task InternalNavigateMenuItemAsync(Type viewModelMasterDetailType, Model.MasterDetail.MenuItem selectedMenuItem, NavigationParameters parameters = null)
{
try
{
Page page = await CreateAndBindPage(selectedMenuItem.ViewModelType, parameters);
if (CurrentApplication.MainPage is MasterDetailPage currentPage)
{
currentPage.Detail = new NavigationPage(page);
currentPage.IsPresented = false;
}
else
{
MasterDetailPage masterDetailPage = await CreateAndBindMasterDetailPage(viewModelMasterDetailType, selectedMenuItem.ViewModelType, parameters);
CurrentApplication.MainPage = masterDetailPage;
if (CurrentApplication.MainPage is MasterDetailPage masterPage)
{
masterPage.IsPresented = false;
}
}
}
catch (Exception ex)
{
ex.LogException();
}
}
public void OnNavigatedFrom(NavigationParameters parameters)
{
}
public async void OnNavigatingTo(NavigationParameters parameters)
{
ToDoItems = new ObservableRangeCollection <ToDoItem>(await _toDoItemsRepository.GetAllAsync());
}
