/// <summary>
/// Raises the Navigating event synchronously.
/// </summary>
/// <param name="uri">A URI value representing the navigation content.</param>
/// <param name="mode">The mode of navigation being initiated (New, Forward or Back)</param>
/// <param name="isFragmentNavigationOnly">True if this navigation is only a fragment navigation on the existing page, false if it is any other type of navigation</param>
/// <returns>A value indicating whether or not to cancel the navigation operation.</returns>
private bool RaiseNavigating(Uri uri, NavigationMode mode, bool isFragmentNavigationOnly)
{
NavigatingCancelEventHandler eventHandler = this.Navigating;
bool canceled = false;
if (eventHandler != null)
{
NavigatingCancelEventArgs eventArgs = new NavigatingCancelEventArgs(uri, mode);
eventHandler(this, eventArgs);
canceled = eventArgs.Cancel;
}
if (!isFragmentNavigationOnly)
{
Page p = this._host.Content as Page;
if (p != null)
{
NavigatingCancelEventArgs eventArgs = new NavigatingCancelEventArgs(uri, mode);
p.InternalOnNavigatingFrom(eventArgs);
canceled |= eventArgs.Cancel;
}
}
return(canceled);
}
private void AddHandler()
{
NavigatedEventHandler successHandler = null;
NavigationFailedEventHandler failureHandler = null;
NavigatingCancelEventHandler beforeHandler = null;
successHandler = (s, e) =>
{
Frame.Navigated -= successHandler;
Frame.NavigationFailed -= failureHandler;
AfterNavigation(null, e.Content as UserControl);
};
failureHandler = (s, e) =>
{
Frame.Navigated -= successHandler;
Frame.NavigationFailed -= failureHandler;
AfterNavigation(e.Exception, null);
};
beforeHandler = (s, e) =>
{
Frame.Navigating -= beforeHandler;
BeforeNavigation();
};
Frame.Navigated += successHandler;
Frame.NavigationFailed += failureHandler;
Frame.Navigating += beforeHandler;
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// navigatingcanceleventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this NavigatingCancelEventHandler navigatingcanceleventhandler, Object sender, NavigatingCancelEventArgs e, AsyncCallback callback)
{
if (navigatingcanceleventhandler == null)
{
throw new ArgumentNullException("navigatingcanceleventhandler");
}
return(navigatingcanceleventhandler.BeginInvoke(sender, e, callback, null));
}
/// <summary>
/// Gets the current <see cref="Application"/> frame.
/// </summary>
/// <returns>Current <see cref="Application"/> frame.</returns>
private PhoneApplicationFrame GetCurrentApplicationFrame()
{
PhoneApplicationFrame frame = Application.Current.RootVisual as PhoneApplicationFrame;
// Could be null, if the app runs inside a design tool.
if (frame != null)
{
frame.Navigating += (s, e) =>
{
NavigatingCancelEventHandler handler = this.Navigating;
if (handler != null)
{
handler(s, e);
}
};
}
return(frame);
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
LoadData_FromDB();
if (!(m_bFstLoad_Done))
{
NavigatingCancelEventHandler m_handler_NavigationService_Navigating =
new NavigatingCancelEventHandler(
this.NavigationService_Navigating);
this.NavigationService.Navigating +=
m_handler_NavigationService_Navigating;
App.Current.Exit += new ExitEventHandler(
this.App_Exit);
m_bFstLoad_Done = true;
}
}
/// <summary>
/// 异步执行
/// </summary>
/// <param name="options"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
var tcs = new TaskCompletionSource <BrowserResult>();
NavigatingCancelEventHandler handler = (sender, e) =>
{
if (e.Uri.AbsoluteUri.StartsWith(options.EndUrl))
{
tcs.SetResult(new BrowserResult {
ResultType = BrowserResultType.Success, Response = e.Uri.ToString()
});
}
};
webBrowser.Navigating += handler;
webBrowser.Navigate(options.StartUrl);
return(tcs.Task.ContinueWith((result) =>
{
webBrowser.Navigating -= handler;
return result.Result;
}));
}
/// <summary>
/// Wait for leaving view-model. Will return the false if the model does not wait for the allotted time <paramref name="timeSpan"/>
/// </summary>
/// <typeparam name="TViewModel">Type view-model</typeparam>
/// <param name="viewModel">await view-model</param>
/// <param name="timeSpan">waiting period</param>
/// <returns></returns>
public async ValueTask <bool> WaitLeaveViewModelAsync <TViewModel>(TViewModel viewModel, TimeSpan timeSpan)
where TViewModel : ViewModelBase
{
bool isLeave = false;
DateTime oparationDate = DateTime.Now;
NavigatingCancelEventHandler hendleLeave = (sender, e) =>
{
if (e.NavigationMode == NavigationMode.Refresh)
{
return;
}
if (_navigationService.Content is Page page)
{
if (page != null && page.DataContext is TViewModel viewModelCompare)
{
isLeave = viewModelCompare == viewModel;
}
}
};
_navigationService.Navigating += hendleLeave;
while (DateTime.Now - oparationDate < timeSpan)
{
if (isLeave)
{
break;
}
await Task.Delay(100);
}
_navigationService.Navigating -= hendleLeave;
return(isLeave);
}
/// <summary>
/// Authorize client using a <see cref="WebBrowser"/> control
/// </summary>
/// <param name="browser">An instantiated <see cref="WebBrowser"/></param>
/// <param name="redirect">oAuth2 redirect param</param>
public void AuthorizeWithWebBrowser(WebBrowser browser, string redirect)
{
//show browser window
if (_navHandler != null) browser.Navigating -= _navHandler;
_navHandler = delegate(object sender, System.Windows.Navigation.NavigatingCancelEventArgs e)
{
if (e.Uri != null)
{
string authCode = HttpUtility.ParseQueryString(e.Uri.Query)["code"];
if (authCode != null)
{
e.Cancel = true;
_code = authCode;
_redirect = redirect;
if (this.Authorized != null) this.Authorized.Invoke(this, null);
}
}
};
browser.Navigating += _navHandler;
browser.Navigate(String.Format("{0}?response_type=code&client_id={1}&redirect_uri={2}", _authEndpoint, this.ClientId, HttpUtility.UrlEncode(redirect)));
}
/// <summary>
/// Provides a secure method for setting the NavigatingEventHandler property. This dependency property indicates ....
/// </summary>
private static void SetNavigatingEventHandler(DependencyObject d, NavigatingCancelEventHandler value)
{
d.SetValue(NavigatingEventHandlerPropertyKey, value);
}
private void NavigateBase(Type viewModelType, Type view, object parameter)
{
if (view == null)
{
throw new Exception("View not found!");
}
ViewModelBase viewModel = null;
bool useDataContext = NavigationManager.GetViewModelInfo(viewModelType).UseDataContextInsteadOfCreating; //(bool)view.GetTypeInfo().GetCustomAttribute<NavigationViewModelAttribute>()?.UseDataContextInsteadOfCreating;
if (!useDataContext)
{
bool viewModelCachingEnabled = Crystal3.CrystalApplication.GetCurrentAsCrystalApplication().Options.EnableViewModelCaching;
if (viewModelCachingEnabled)
{
viewModel = Crystal3.CrystalApplication.GetCurrentAsCrystalApplication().ResolveCachedViewModel(viewModelType);
}
}
NavigatingCancelEventHandler navigatingHandler = null;
navigatingHandler = new NavigatingCancelEventHandler((object sender, Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) =>
{
NavigationFrame.Navigating -= navigatingHandler;
if (!useDataContext) //we can't access the data context in this event so don't even bother
{
if (e.NavigationMode == NavigationMode.New || e.NavigationMode == NavigationMode.Refresh)
{
if (viewModel == null)
{
viewModel = CreateViewModelFromType(viewModelType) as ViewModelBase;
}
viewModel.NavigationService = this;
if (lastViewModel != null)
{
e.Cancel = lastViewModel.OnNavigatingFrom(sender, new CrystalNavigationEventArgs(e)
{
Direction = ConvertToCrystalNavDirections(e.NavigationMode)
});
}
viewModel.OnNavigatingTo(sender, new CrystalNavigationEventArgs(e)
{
Direction = ConvertToCrystalNavDirections(e.NavigationMode)
});
}
//else if (e.NavigationMode == NavigationMode.Back)
//{
// e.Cancel = viewModel.OnNavigatingFrom(sender, e);
//}
}
});
NavigatedEventHandler navigatedHandler = null;
navigatedHandler = new NavigatedEventHandler((object sender, Windows.UI.Xaml.Navigation.NavigationEventArgs e) =>
{
NavigationFrame.Navigated -= navigatedHandler;
InvokePreNavigatedEvent(new NavigationServicePreNavigatedSignaledEventArgs(viewModel, new CrystalNavigationEventArgs(e)));
if (e.NavigationMode == NavigationMode.New)
{
if (lastViewModel != null)
{
lastViewModel.OnNavigatedFrom(sender, new CrystalNavigationEventArgs(e)
{
Direction = ConvertToCrystalNavDirections(e.NavigationMode)
});
viewModelBackStack.Push(lastViewModel);
}
Page page = e.Content as Page;
//page.NavigationCacheMode = NavigationCacheMode.Enabled;
if (!useDataContext)
{
page.DataContext = viewModel;
}
else
{
viewModel = page.DataContext as ViewModelBase;
}
if (viewModel == null)
{
throw new Exception();
}
if (viewModel is UIViewModelBase)
{
((UIViewModelBase)viewModel).UI.SetUIElement(page);
}
//page.SetValue(FrameworkElement.DataContextProperty, viewModel);
viewModel.OnNavigatedTo(sender, new CrystalNavigationEventArgs(e)
{
Direction = ConvertToCrystalNavDirections(e.NavigationMode)
});
lastViewModel = viewModel;
}
//else if (e.NavigationMode == NavigationMode.Back)
//{
// viewModel.OnNavigatedFrom(sender, e);
//}
InvokeNavigatedEvent(new CrystalNavigationEventArgs(e)
{
Direction = ConvertToCrystalNavDirections(e.NavigationMode), Parameter = e.Parameter
});
navigationLock.Set();
});
navigationLock.Reset();
NavigationFrame.Navigated += navigatedHandler;
NavigationFrame.Navigating += navigatingHandler;
NavigationFrame.Navigate(view, parameter);
}
