The event arguments associated with the Navigating event.
Inheritance: CancelEventArgs
示例#1
0
 /// <summary>
 /// Raises the Navigating event.
 /// </summary>
 /// <param name="e">The data associated with the event.</param>
 protected internal virtual void OnNavigating(PageNavigatingEventArgs e)
 {
     if (e.CanCancel && e.Canceled) {
         return;
     }
     if (_navigatingHandler != null) {
         _navigatingHandler(this, e);
     }
 }
示例#2
0
        private void NavigateInternal(NavigationState navigationState)
        {
            if (_contentView == null) {
                return;
            }

            // TODO: False if we don't own journal and this navigation request is
            //       because of a browser-based back/fwd/address change gesture
            bool canCancel = true;

            Page currentPage = Page;
            if (currentPage != null) {
                PageNavigatingEventArgs e = new PageNavigatingEventArgs(canCancel);
                currentPage.OnNavigating(e);

                if (canCancel && e.Canceled) {
                    return;
                }
            }

            NavigatingEventArgs ne = new NavigatingEventArgs(navigationState.uri, canCancel);
            OnNavigating(ne);
            if (canCancel && ne.Canceled) {
                return;
            }

            Page page = _cache.GetPage(navigationState.uri);
            if (page != null) {
                navigationState.cachedPage = true;
                Dispatcher.BeginInvoke(delegate() {
                    OnNavigationCompleted(navigationState, page);
                });
                return;
            }

            VisualStateManager.GoToState(this, "Navigating", /* useTransitions */ true);
            InitiateNavigation(navigationState);
        }
示例#3
0
        private bool NavigateInternal(NavigationState navigationState)
        {
            if (_contentView == null) {
                return true;
            }
            if (_navigateResult != null) {
                ((NavigationState)_navigateResult.AsyncState).canceled = true;
                _navigateResult = null;
            }

            Page currentPage = Page;

            string fragment;
            if (navigationState.uri.TryGetFragment(out fragment)) {
                if (navigationState.uri.GetPath() == null) {
                    // Fragment navigation

                    if (currentPage != null) {
                        UriData currentUri = new UriData(currentPage.OriginalUri);
                        currentUri.SetFragment(fragment);

                        Uri newUri = currentUri.GetUri();
                        _journal.AddEntry(newUri);
                        _backCommand.UpdateStatus(_journal.CanGoBack);
                        _forwardCommand.UpdateStatus(_journal.CanGoForward);

                        currentPage.OnStateChanged(new PageStateEventArgs(fragment));

                        return true;
                    }

                    return false;
                }
                else {
                    navigationState.fragment = fragment;
                    navigationState.uri.SetFragment(null);
                }
            }

            if (_redirecting == false) {
                bool canCancel = !_journal.IsIntegratedWithBrowser;

                if (currentPage != null) {
                    PageNavigatingEventArgs e = new PageNavigatingEventArgs(canCancel);
                    currentPage.OnNavigating(e);

                    if (canCancel && e.Cancel) {
                        return false;
                    }
                }

                NavigatingEventArgs ne = new NavigatingEventArgs(navigationState.uri.OriginalUri, canCancel);
                OnNavigating(ne);
                if (canCancel && ne.Cancel) {
                    return false;
                }
            }

            Page page = _cache.GetPage(navigationState.uri.OriginalUri);
            if (page != null) {
                navigationState.cachedPage = true;
                Dispatcher.BeginInvoke(delegate() {
                    OnNavigationCompleted(navigationState, page);
                });
                return true;
            }

            try {
                IAsyncResult navigateResult = _loader.BeginLoadPage(navigationState.uri.GetUri(), Page,
                                                                    OnPageLoadCallback, navigationState);
                if (navigateResult.CompletedSynchronously == false) {
                    _navigateResult = navigateResult;
                    IsNavigating = true;
                }
            }
            catch (Exception e) {
                Page errorPage = GetErrorPage(e);

                Dispatcher.BeginInvoke(delegate() {
                    OnNavigationCompleted(navigationState, errorPage);
                });
            }

            return true;
        }
示例#4
0
        private bool NavigateInternal(NavigationState navigationState)
        {
            if (navigationState.uri.IsAbsoluteUri == true) {
                throw new ArgumentException("The URI must be a relative URI.");
            }
            if (_contentView == null) {
                return true;
            }

            Page currentPage = Page;

            string url = navigationState.originalUri.ToString();

            int fragmentIndex = url.IndexOf('#');
            if (url.Length <= fragmentIndex + 1) {
                throw new ArgumentException("Invalid URL");
            }
            string fragment = url.Substring(fragmentIndex + 1);

            if (fragmentIndex > 0) {
                navigationState.fragment = fragment;
                navigationState.uri = new Uri(url.Substring(0, fragmentIndex), UriKind.Relative);
            }
            else if (fragmentIndex == 0) {
                if (currentPage != null) {
                    string currentUrl = currentPage.OriginalUri.ToString();
                    int currentFragmentIndex = currentUrl.IndexOf('#');

                    if (currentFragmentIndex > 0) {
                        currentUrl = currentUrl.Substring(0, currentFragmentIndex);
                    }

                    url = currentUrl + "#" + fragment;

                    _journal.AddEntry(new Uri(url, UriKind.Relative));
                    _backCommand.UpdateStatus(_journal.CanGoBack);
                    _forwardCommand.UpdateStatus(_journal.CanGoForward);

                    currentPage.OnStateChanged(new PageStateEventArgs(fragment));

                    return true;
                }

                return false;
            }

            if (_redirecting == false) {
                // TODO: False if we don't own journal and this navigation request is
                //       because of a browser-based back/fwd/address change gesture
                bool canCancel = true;

                if (currentPage != null) {
                    PageNavigatingEventArgs e = new PageNavigatingEventArgs(canCancel);
                    currentPage.OnNavigating(e);

                    if (canCancel && e.Canceled) {
                        return false;
                    }
                }

                NavigatingEventArgs ne = new NavigatingEventArgs(navigationState.originalUri, canCancel);
                OnNavigating(ne);
                if (canCancel && ne.Canceled) {
                    return false;
                }
            }

            Page page = _cache.GetPage(navigationState.originalUri);
            if (page != null) {
                navigationState.cachedPage = true;
                Dispatcher.BeginInvoke(delegate() {
                    OnNavigationCompleted(navigationState, page);
                });
                return true;
            }

            if (_uriMapper != null) {
                navigationState.uri = _uriMapper.MapPageUri(navigationState.uri);
            }

            IsNavigating = true;

            try {
                _navigateResult = _loader.BeginLoadPage(navigationState.uri, Page, OnPageLoadCallback, navigationState);
            }
            catch (Exception e) {
                Page errorPage = GetErrorPage(e);

                Dispatcher.BeginInvoke(delegate() {
                    OnNavigationCompleted(navigationState, errorPage);
                });
            }

            return true;
        }