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