Example #1
0
        public override async void Navigate(PageIndex index, object args = null)
        {
            PageIndex originalIndex   = index;
            var       wasOnSearchPage = SearchToggleLock;

            SearchToggleLock = false;
            if (View.CurrentDisplayMode == SplitViewDisplayMode.CompactOverlay)
            {
                MenuPaneState = false;
            }
            CurrentStatusSub          = "";
            IsCurrentStatusSelectable = false;
            if (!Credentials.Authenticated && PageUtils.PageRequiresAuth(index))
            {
                var msg = new MessageDialog("Log in first in order to access this page.");
                await msg.ShowAsync();

                return;
            }
            if (index == PageIndex.PageForumIndex && args is ForumsNavigationArgs arg)
            {
                ResourceLocator.TelemetryProvider.TelemetryTrackNavigation(arg.Page);
            }
            else
            {
                ResourceLocator.TelemetryProvider.TelemetryTrackNavigation(index);
            }
            ScrollToTopButtonVisibility = false;
            RefreshButtonVisibility     = false;

            if (index == PageIndex.PageMangaList && args == null) // navigating from startup
            {
                args = AnimeListPageNavigationArgs.Manga;
            }

            if (index == PageIndex.PageSeasonal || //index is always angry btw
                index == PageIndex.PageMangaList ||
                index == PageIndex.PageTopManga ||
                index == PageIndex.PageTopAnime)
            {
                index = PageIndex.PageAnimeList;
            }

            MobileViewModelLocator.Hamburger.ChangeBottomStackPanelMargin(index == PageIndex.PageAnimeList || //and she likes to bit certain individual
                                                                          index == PageIndex.PageMessanging ||
                                                                          index == PageIndex.PageSearch ||
                                                                          index == PageIndex.PageWallpapers);

            if (index == PageIndex.PageAnimeList && _searchStateBeforeNavigatingToSearch != null)
            {
                SearchToggleStatus = (bool)_searchStateBeforeNavigatingToSearch;
                if (SearchToggleStatus)
                {
                    ShowSearchStuff();
                }
                else
                {
                    HideSearchStuff();
                }
            }

            ResetSearchFilter();
            switch (index) //his head specifficaly
            {
            case PageIndex.PageAnimeList:
                if (MobileViewModelLocator.AnimeList.Initializing)
                {
                    if (!_subscribed)
                    {
                        MobileViewModelLocator.AnimeList.Initialized += AnimeListOnInitialized;
                        _subscribed = true;
                    }
                    _postponedNavigationArgs = new Tuple <PageIndex, object>(originalIndex, args);
                    return;
                }
                MobileViewModelLocator.Hamburger.SetActiveButton(HamburgerButtons.AnimeList);
                ShowSearchStuff();
                if ((_searchStateBeforeNavigatingToSearch == null || !_searchStateBeforeNavigatingToSearch.Value) &&
                    (wasOnSearchPage || _wasOnDetailsFromSearch))
                {
                    CurrentSearchQuery      = "";
                    _wasOnDetailsFromSearch = false;
                    UnToggleSearchStuff();
                }
                if (CurrentMainPage == PageIndex.PageAnimeList)
                {
                    MobileViewModelLocator.AnimeList.Init(args as AnimeListPageNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(AnimeListPage), args);
                }
                break;

            case PageIndex.PageAnimeDetails:
                HideSearchStuff();
                var detail = ViewModelLocator.AnimeDetails;
                detail.DetailImage = null;
                detail.LeftDetailsRow.Clear();
                detail.RightDetailsRow.Clear();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.AnimeDetails.RefreshData());
                _wasOnDetailsFromSearch = (args as AnimeDetailsPageNavigationArgs).Source == PageIndex.PageSearch;
                //from search , details are passed instead of being downloaded once more
                if (CurrentMainPage == PageIndex.PageAnimeDetails)
                {
                    ViewModelLocator.AnimeDetails.Init(args as AnimeDetailsPageNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(AnimeDetailsPage), args);
                }
                break;

            case PageIndex.PageSettings:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(typeof(SettingsPage));
                break;

            case PageIndex.PageSearch:
            case PageIndex.PageMangaSearch:
                if (CurrentMainPage != PageIndex.PageSearch && CurrentMainPage != PageIndex.PageMangaSearch && CurrentMainPage != PageIndex.PageCharacterSearch)
                {
                    _searchStateBeforeNavigatingToSearch = SearchToggleStatus;
                }

                var searchArg = args as SearchPageNavigationArgs;
                if (string.IsNullOrWhiteSpace(searchArg.Query))
                {
                    searchArg.Query = CurrentSearchQuery;
                }
                if (!searchArg.ByGenre && !searchArg.ByStudio)
                {
                    View.SearchInputFocus(FocusState.Keyboard);
                    SearchToggleLock = true;
                    ShowSearchStuff();
                    ToggleSearchStuff();
                }
                else
                {
                    HideSearchStuff();
                    CurrentStatus = searchArg.ByGenre ? "Anime by Genre" : "Anime By Studio";
                }
                MainNavigationRequested?.Invoke(typeof(AnimeSearchPage), args);
                break;

            case PageIndex.PageLogIn:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(typeof(LogInPage));
                break;

            case PageIndex.PageProfile:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                if (Settings.SelectedApiType == ApiType.Mal)
                {
                    RefreshDataCommand =
                        new RelayCommand(() => ViewModelLocator.ProfilePage.LoadProfileData(null, true));
                }
                else
                {
                    RefreshDataCommand = new RelayCommand(() => ViewModelLocator.HumProfilePage.Init(true));
                }
                if (Settings.SelectedApiType == ApiType.Mal)
                {
                    if (CurrentMainPage == PageIndex.PageProfile)
                    {
                        MobileViewModelLocator.ProfilePage.LoadProfileData(args as ProfilePageNavigationArgs);
                    }
                    else
                    {
                        MainNavigationRequested?.Invoke(typeof(ProfilePage), args);
                    }
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(HummingbirdProfilePage), args);
                }
                break;

            case PageIndex.PageRecomendations:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(typeof(RecommendationsPage), args);
                break;

            case PageIndex.PageCalendar:
                HideSearchStuff();
                CurrentStatus           = "Calendar";
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.CalendarPage.Init(true); });
                MainNavigationRequested?.Invoke(typeof(CalendarPage), args);
                break;

            case PageIndex.PageArticles:
            case PageIndex.PageNews:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.MalArticles.Init(null));
                if (CurrentMainPage == PageIndex.PageArticles)
                {
                    ViewModelLocator.MalArticles.Init(args as MalArticlesPageNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(MalArticlesPage), args);
                }
                break;

            case PageIndex.PageMessanging:
                HideSearchStuff();
                CurrentStatus           = $"{Credentials.UserName} - Messages";
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.MalMessaging.Init(true); });
                MainNavigationRequested?.Invoke(typeof(MalMessagingPage), args);
                break;

            case PageIndex.PageMessageDetails:
                var msgModel = args as MalMessageDetailsNavArgs;
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.MalMessageDetails.RefreshData());
                CurrentOffStatus        = msgModel.WorkMode == MessageDetailsWorkMode.Message
                        ? (msgModel.Arg != null
                            ? $"{(msgModel.Arg as MalMessageModel)?.Sender} - {(msgModel.Arg as MalMessageModel)?.Subject}"
                            : "New Message")
                        : $"Comments {Credentials.UserName} - {(msgModel.Arg as MalComment)?.User.Name}";
                MainNavigationRequested?.Invoke(typeof(MalMessageDetailsPage), args);
                break;

            case PageIndex.PageForumIndex:
                HideSearchStuff();
                CurrentStatus = "Forums";
                if (args == null || (args as ForumsNavigationArgs)?.Page == ForumsPageIndex.PageIndex)
                {
                    RefreshButtonVisibility = true;
                    RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsIndex.Init(true); });
                }
                else
                {
                    var navArgs = args as ForumsNavigationArgs;
                    if (navArgs?.Page == ForumsPageIndex.PageBoard)
                    {
                        RefreshButtonVisibility = true;
                        RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsBoard.Reload(); });
                    }
                    else if (navArgs?.Page == ForumsPageIndex.PageTopic)
                    {
                        RefreshButtonVisibility = true;
                        RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsTopic.Reload(); });
                    }
                }
                if (CurrentMainPage == PageIndex.PageForumIndex)
                {
                    ViewModelLocator.ForumsMain.Init(args as ForumsNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(ForumsMainPage), args);
                }
                break;

            case PageIndex.PageHistory:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.History.Init(null, true); });
                CurrentStatus           = $"History - {(args as HistoryNavigationArgs)?.Source ?? Credentials.UserName}";
                MainNavigationRequested?.Invoke(typeof(HistoryPage), args);
                break;

            case PageIndex.PageCharacterDetails:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.CharacterDetails.RefreshData());
                OffContentVisibility    = true;

                if (CurrentOffPage == PageIndex.PageCharacterDetails)
                {
                    ViewModelLocator.CharacterDetails.Init(args as CharacterDetailsNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(CharacterDetailsPage), args);
                }
                break;

            case PageIndex.PageStaffDetails:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.StaffDetails.RefreshData());
                OffContentVisibility    = true;

                if (CurrentOffPage == PageIndex.PageStaffDetails)
                {
                    ViewModelLocator.StaffDetails.Init(args as StaffDetailsNaviagtionArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(StaffDetailsPage), args);
                }
                break;

            case PageIndex.PageCharacterSearch:
                if (CurrentMainPage != PageIndex.PageSearch && CurrentMainPage != PageIndex.PageMangaSearch && CurrentMainPage != PageIndex.PageCharacterSearch)
                {
                    _searchStateBeforeNavigatingToSearch = SearchToggleStatus;
                }
                ShowSearchStuff();
                ToggleSearchStuff();

                SearchToggleLock = true;

                MainNavigationRequested?.Invoke(typeof(CharacterSearchPage));
                await Task.Delay(10);

                View.SearchInputFocus(FocusState.Keyboard);
                break;

            case PageIndex.PageWallpapers:
                HideSearchStuff();
                RefreshButtonVisibility = false;
                MainNavigationRequested?.Invoke(typeof(WallpapersPage), args);
                break;

            case PageIndex.PagePopularVideos:
                HideSearchStuff();
                CurrentStatus = "Popular Videos";
                MainNavigationRequested?.Invoke(typeof(PopularVideosPage), args);
                break;

            case PageIndex.PageFeeds:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.FriendsFeeds.Init(true));
                CurrentStatus           = "Friends Feeds";
                MainNavigationRequested?.Invoke(typeof(FriendsFeedsPage), args);
                break;

            case PageIndex.PageNotificationHub:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.NotificationsHub.Init(true));
                CurrentStatus           = "Notifications";
                MainNavigationRequested?.Invoke(typeof(NotificationsHubPage), args);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(index), index, null);
            }
            CurrentMainPage     = index;
            CurrentMainPageKind = index;
            RaisePropertyChanged(() => SearchToggleLock);
        }
Example #2
0
        public override async void Navigate(PageIndex index, object args = null)
        {
            PageIndex?currPage        = null;
            PageIndex?currOffPage     = null;
            var       mainPage        = true;
            var       originalIndex   = index;
            var       wasOnSearchPage = SearchToggleLock;

            if (!Credentials.Authenticated && PageUtils.PageRequiresAuth(index))
            {
                var msg = new MessageDialog("Log in first in order to access this page."
                                            , "Login required.");
                await msg.ShowAsync();

                return;
            }
            _navigating = true;
            ResourceLocator.TelemetryProvider.TelemetryTrackEvent(TelemetryTrackedEvents.Navigated, index.ToString());


            DesktopViewModelLocator.Hamburger.UpdateAnimeFiltersSelectedIndex();
            //prepare for some index mess
            if (index == PageIndex.PageMangaList && args == null) // navigating from startup
            {
                args = AnimeListPageNavigationArgs.Manga;
            }

            if (index == PageIndex.PageAbout ||
                index == PageIndex.PageSettings ||
                index == PageIndex.PageAbout ||
                index == PageIndex.PageAnimeDetails ||
                index == PageIndex.PageMessageDetails ||
                index == PageIndex.PageCharacterDetails ||
                index == PageIndex.PageStaffDetails ||
                index == PageIndex.PageLogIn)
            {
                OffRefreshButtonVisibility = false;
                mainPage = false;
                IsCurrentStatusSelectable = false;
                currOffPage = index;
                if (index != PageIndex.PageAnimeDetails)
                {
                    ViewModelLocator.AnimeDetails.Id = 0; //reset this because we no longer are there
                    if (index != PageIndex.PageCharacterDetails && index != PageIndex.PageStaffDetails)
                    {
                        ViewModelLocator.NavMgr.ResetOffBackNav();
                    }
                }
                if (CurrentOffPage == PageIndex.PageSettings)
                {
                    ViewModelLocator.NavMgr.ResetOffBackNav();
                }
            }
            else //naviagating main page
            {
                ScrollToTopButtonVisibility = false;
                RefreshButtonVisibility     = false;
                ResetSearchFilter();
                SearchToggleLock = false;
                CurrentHintSet   = null;
            }

            switch (index)
            {
            case PageIndex.PageSeasonal:
            case PageIndex.PageMangaList:
            case PageIndex.PageTopManga:
            case PageIndex.PageTopAnime:
            case PageIndex.PageAnimeList:
                if (index == PageIndex.PageSeasonal || index == PageIndex.PageTopAnime ||
                    index == PageIndex.PageTopManga || index == PageIndex.PageMangaList)
                {
                    currPage = index;     //used by hamburger's filters
                }
                else
                {
                    currPage = PageIndex.PageAnimeList;
                }
                DesktopViewModelLocator.Hamburger.ChangeBottomStackPanelMargin(true);
                index = PageIndex.PageAnimeList;
                break;

            case PageIndex.PageSearch:
            case PageIndex.PageRecomendations:
            case PageIndex.PageProfile:
            case PageIndex.PageMangaSearch:
            case PageIndex.PageCalendar:
            case PageIndex.PageArticles:
            case PageIndex.PageNews:
            case PageIndex.PageMessanging:
            case PageIndex.PageForumIndex:
            case PageIndex.PageHistory:
            case PageIndex.PageCharacterSearch:
            case PageIndex.PageWallpapers:
            case PageIndex.PagePopularVideos:
            case PageIndex.PageFeeds:
            case PageIndex.PageNotificationHub:

                if (index == PageIndex.PageSearch || index == PageIndex.PageMangaSearch ||
                    ((index == PageIndex.PageSearch || index == PageIndex.PageMangaSearch) &&
                     CurrentOffPage == PageIndex.PageSearch))
                {
                    var arg = args as SearchPageNavigationArgs;
                    if (Settings.ForceSearchIntoOffPage || CurrentMainPage == PageIndex.PageForumIndex ||
                        CurrentMainPage == PageIndex.PageProfile || CurrentOffPage == PageIndex.PageSearch)
                    {
                        arg.DisplayMode = SearchPageDisplayModes.Off;
                        args            = arg;
                    }
                    if ((args as SearchPageNavArgsBase).DisplayMode == SearchPageDisplayModes.Main)
                    {
                        CurrentStatusSub = "";
                        DesktopViewModelLocator.Hamburger.ChangeBottomStackPanelMargin(index == PageIndex.PageMessanging || index == PageIndex.PageWallpapers);
                    }
                }
                else
                {
                    CurrentStatusSub = "";
                    DesktopViewModelLocator.Hamburger.ChangeBottomStackPanelMargin(index == PageIndex.PageMessanging || index == PageIndex.PageWallpapers);
                }
                currPage = index;
                break;
            }

            if (index == PageIndex.PageAnimeList && _searchStateBeforeNavigatingToSearch != null)
            {
                SearchToggleStatus = (bool)_searchStateBeforeNavigatingToSearch;
                if (SearchToggleStatus)
                {
                    ShowSearchStuff();
                }
                else
                {
                    HideSearchStuff();
                }
            }

            switch (index)
            {
            case PageIndex.PageAnimeList:
                if (ViewModelLocator.AnimeList.Initializing)
                {
                    if (!_subscribed)
                    {
                        ViewModelLocator.AnimeList.Initialized += AnimeListOnInitialized;
                        _subscribed = true;
                    }
                    _postponedNavigationArgs = new Tuple <PageIndex, object>(originalIndex, args);
                    return;
                }
                _postponedNavigationArgs = null;
                ShowSearchStuff();
                if ((_searchStateBeforeNavigatingToSearch == null || !_searchStateBeforeNavigatingToSearch.Value) &&
                    (wasOnSearchPage || _wasOnDetailsFromSearch))
                {
                    CurrentSearchQuery      = "";
                    _wasOnDetailsFromSearch = false;
                    UnToggleSearchStuff();
                }
                if (CurrentMainPageKind == PageIndex.PageAnimeList)
                {
                    ViewModelLocator.AnimeList.Init(args as AnimeListPageNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(AnimeListPage), args);
                }
                break;

            case PageIndex.PageAnimeDetails:
                var detail = ViewModelLocator.AnimeDetails;
                detail.DetailImage = null;
                detail.LeftDetailsRow.Clear();
                detail.RightDetailsRow.Clear();
                OffRefreshButtonVisibility = true;
                RefreshOffDataCommand      = new RelayCommand(() => ViewModelLocator.AnimeDetails.RefreshData());
                _wasOnDetailsFromSearch    = (args as AnimeDetailsPageNavigationArgs).Source == PageIndex.PageSearch;
                //from search , details are passed instead of being downloaded once more
                OffContentVisibility = true;

                if (CurrentOffPage == PageIndex.PageAnimeDetails)
                {
                    ViewModelLocator.AnimeDetails.Init(args as AnimeDetailsPageNavigationArgs);
                }
                else
                {
                    OffNavigationRequested?.Invoke(typeof(AnimeDetailsPage), args);
                }
                break;

            case PageIndex.PageSettings:
                OffContentVisibility = true;
                OffNavigationRequested?.Invoke(typeof(SettingsPage));
                break;

            case PageIndex.PageSearch:
            case PageIndex.PageMangaSearch:
                var arg = args as SearchPageNavigationArgs;
                if (Settings.ForceSearchIntoOffPage || CurrentMainPage == PageIndex.PageForumIndex || CurrentMainPage == PageIndex.PageProfile)
                {
                    arg.DisplayMode = SearchPageDisplayModes.Off;
                }
                if (arg.DisplayMode == SearchPageDisplayModes.Off)
                {
                    if (CurrentMainPage == PageIndex.PageCharacterSearch)
                    {
                        ToggleSearchStuff();
                        SearchToggleLock = true;
                    }
                    if (CurrentMainPage == PageIndex.PageSearch)
                    {
                        break;     // we are already on the left
                    }
                    if (string.IsNullOrWhiteSpace(arg.Query))
                    {
                        arg.Query = CurrentSearchQuery;
                    }
                    arg.DisplayMode                  = SearchPageDisplayModes.Off;
                    OffContentVisibility             = true;
                    currOffPage                      = PageIndex.PageSearch;
                    currPage                         = null;
                    OffRefreshButtonVisibility       = false;
                    ViewModelLocator.AnimeDetails.Id = -1;
                    StatusFilterVisibilityLock       = false;
                    CurrentOffStatus                 = "Search";
                    IsCurrentStatusSelectable        = false;
                    OffNavigationRequested?.Invoke(typeof(AnimeSearchPage), args);
                }
                else
                {
                    if (CurrentOffPage == PageIndex.PageSearch)
                    {
                        break;     // we are already on the right
                    }
                    if (CurrentMainPage.Value != PageIndex.PageSearch &&
                        CurrentMainPage.Value != PageIndex.PageMangaSearch &&
                        CurrentMainPage.Value != PageIndex.PageCharacterSearch)
                    {
                        _searchStateBeforeNavigatingToSearch = SearchToggleStatus;
                    }
                    if (arg.ByGenre || arg.ByStudio)
                    {
                        CurrentStatus = $"Anime by {(arg.ByGenre ? "Genre" : "Studio")}";
                        HideSearchStuff();
                    }
                    else
                    {
                        SearchToggleLock = true;
                        ShowSearchStuff();
                        ToggleSearchStuff();
                    }

                    StatusFilterVisibilityLock = true;
                    if (string.IsNullOrWhiteSpace(arg.Query))
                    {
                        arg.Query = CurrentSearchQuery;
                    }
                    MainNavigationRequested?.Invoke(typeof(AnimeSearchPage), args);
                    await Task.Delay(10);

                    View.SearchInputFocus(FocusState.Keyboard);
                }
                break;

            case PageIndex.PageLogIn:
                OffContentVisibility = true;
                OffNavigationRequested?.Invoke(typeof(LogInPage));
                break;

            case PageIndex.PageProfile:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                if (Settings.SelectedApiType == ApiType.Mal)
                {
                    RefreshDataCommand =
                        new RelayCommand(() => DesktopViewModelLocator.ProfilePage.LoadProfileData(null, true));
                }
                else
                {
                    RefreshDataCommand = new RelayCommand(() => ViewModelLocator.HumProfilePage.Init(true));
                }
                if (Settings.SelectedApiType == ApiType.Mal)
                {
                    if (CurrentMainPage == PageIndex.PageProfile)
                    {
                        DesktopViewModelLocator.ProfilePage.LoadProfileData(args as ProfilePageNavigationArgs);
                    }
                    else
                    {
                        MainNavigationRequested?.Invoke(typeof(ProfilePage), args);
                    }
                }

                else
                {
                    MainNavigationRequested?.Invoke(typeof(HummingbirdProfilePage), args);
                }
                break;

            case PageIndex.PageRecomendations:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.Recommendations.PopulateData(true));
                MainNavigationRequested?.Invoke(typeof(RecommendationsPage), args);
                break;

            case PageIndex.PageCalendar:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.CalendarPage.Init(true));
                CurrentStatus           = "Calendar";
                MainNavigationRequested?.Invoke(typeof(CalendarPage), args);
                break;

            case PageIndex.PageArticles:
            case PageIndex.PageNews:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.MalArticles.Init(null); });
                MainNavigationRequested?.Invoke(typeof(MalArticlesPage), args);
                break;

            case PageIndex.PageMessanging:
                HideSearchStuff();
                CurrentStatus           = $"{Credentials.UserName} - Messages";
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.MalMessaging.Init(true); });
                MainNavigationRequested?.Invoke(typeof(MalMessagingPage), args);
                break;

            case PageIndex.PageMessageDetails:
                var msgModel = args as MalMessageDetailsNavArgs;
                OffRefreshButtonVisibility = true;
                RefreshOffDataCommand      = new RelayCommand(() => ViewModelLocator.MalMessageDetails.RefreshData());
                CurrentOffStatus           = msgModel.WorkMode == MessageDetailsWorkMode.Message
                        ? (msgModel.Arg != null
                            ? $"{(msgModel.Arg as MalMessageModel)?.Sender} - {(msgModel.Arg as MalMessageModel)?.Subject}"
                            : "New Message")
                        : $"Comments {Credentials.UserName} - {(msgModel.Arg as MalComment)?.User.Name}";
                OffContentVisibility = true;
                OffNavigationRequested?.Invoke(typeof(MalMessageDetailsPage), args);
                break;

            case PageIndex.PageForumIndex:
                HideSearchStuff();
                CurrentStatus = "Forums";
                if (args == null || (args as ForumsNavigationArgs)?.Page == ForumsPageIndex.PageIndex)
                {
                    RefreshButtonVisibility = true;
                    RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsIndex.Init(true); });
                }
                else
                {
                    var navArgs = args as ForumsNavigationArgs;
                    if (navArgs?.Page == ForumsPageIndex.PageBoard)
                    {
                        RefreshButtonVisibility = true;
                        RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsBoard.Reload(); });
                    }
                    else if (navArgs?.Page == ForumsPageIndex.PageTopic)
                    {
                        RefreshButtonVisibility = true;
                        RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsTopic.Reload(); });
                    }
                }
                if (CurrentMainPage != null && CurrentMainPage == PageIndex.PageForumIndex)
                {
                    ViewModelLocator.ForumsMain.Init(args as ForumsNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(typeof(ForumsMainPage), args);
                }
                break;

            case PageIndex.PageHistory:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.History.Init(null, true); });
                CurrentStatus           = $"History - {(args as HistoryNavigationArgs)?.Source ?? Credentials.UserName}";
                MainNavigationRequested?.Invoke(typeof(HistoryPage), args);
                break;

            case PageIndex.PageCharacterDetails:
                OffRefreshButtonVisibility = true;
                RefreshOffDataCommand      = new RelayCommand(() => ViewModelLocator.CharacterDetails.RefreshData());
                OffContentVisibility       = true;

                if (CurrentOffPage == PageIndex.PageCharacterDetails)
                {
                    ViewModelLocator.CharacterDetails.Init(args as CharacterDetailsNavigationArgs);
                }
                else
                {
                    OffNavigationRequested?.Invoke(typeof(CharacterDetailsPage), args);
                }
                break;

            case PageIndex.PageStaffDetails:
                OffRefreshButtonVisibility = true;
                RefreshOffDataCommand      = new RelayCommand(() => ViewModelLocator.StaffDetails.RefreshData());
                OffContentVisibility       = true;

                if (CurrentOffPage == PageIndex.PageStaffDetails)
                {
                    ViewModelLocator.StaffDetails.Init(args as StaffDetailsNaviagtionArgs);
                }
                else
                {
                    OffNavigationRequested?.Invoke(typeof(StaffDetailsPage), args);
                }
                break;

            case PageIndex.PageCharacterSearch:
                if (CurrentMainPage.Value != PageIndex.PageSearch &&
                    CurrentMainPage.Value != PageIndex.PageMangaSearch &&
                    CurrentMainPage.Value != PageIndex.PageCharacterSearch)
                {
                    _searchStateBeforeNavigatingToSearch = SearchToggleStatus;
                }
                ShowSearchStuff();
                ToggleSearchStuff();

                SearchToggleLock = true;
                if (CurrentMainPage != PageIndex.PageCharacterSearch)
                {
                    MainNavigationRequested?.Invoke(typeof(CharacterSearchPage));
                }
                await Task.Delay(10);

                View.SearchInputFocus(FocusState.Keyboard);
                break;

            case PageIndex.PageWallpapers:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(typeof(WallpapersPage), args);
                break;

            case PageIndex.PagePopularVideos:
                HideSearchStuff();
                CurrentStatus = "Promotional Videos";
                MainNavigationRequested?.Invoke(typeof(PopularVideosPage), args);
                break;

            case PageIndex.PageFeeds:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.FriendsFeeds.Init(true));
                CurrentStatus           = "Friends Feeds";
                MainNavigationRequested?.Invoke(typeof(FriendsFeedsPage), args);
                break;

            case PageIndex.PageNotificationHub:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.NotificationsHub.Init(true));
                CurrentStatus           = "Notifications";
                MainNavigationRequested?.Invoke(typeof(NotificationsHubPage), args);
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(index), index, null);
            }
            if (currPage != null)
            {
                CurrentMainPage = currPage;
            }
            if (mainPage)
            {
                CurrentMainPageKind = index;
            }
            if (currOffPage != null)
            {
                CurrentOffPage = currOffPage;
            }
            LastNavArgs = args;
            _navigating = false;
            RaisePropertyChanged(() => SearchToggleLock);
        }
Example #3
0
        public override void Navigate(PageIndex index, object args = null)
        {
            PageIndex originalIndex   = index;
            var       wasOnSearchPage = SearchToggleLock;

            SearchToggleLock          = false;
            CurrentStatusSub          = "";
            IsCurrentStatusSelectable = false;
            if (!Credentials.Authenticated && PageUtils.PageRequiresAuth(index))
            {
                ResourceLocator.MessageDialogProvider.ShowMessageDialog("Log in first in order to access this page.", "Log in required");
                return;
            }
            if (index == PageIndex.PageForumIndex && args is ForumsNavigationArgs arg)
            {
                ResourceLocator.TelemetryProvider.TelemetryTrackNavigation(arg.Page);
            }
            else
            {
                ResourceLocator.TelemetryProvider.TelemetryTrackNavigation(index);
            }

            ScrollToTopButtonVisibility      = false;
            RefreshButtonVisibility          = false;
            ViewModelLocator.AnimeDetails.Id = -1;

            if (index == PageIndex.PageMangaList && args == null) // navigating from startup
            {
                args = AnimeListPageNavigationArgs.Manga;
            }

            if (index == PageIndex.PageSeasonal ||
                index == PageIndex.PageMangaList ||
                index == PageIndex.PageTopManga ||
                index == PageIndex.PageTopAnime)
            {
                index = PageIndex.PageAnimeList;
            }



            if (index == PageIndex.PageAnimeList && _searchStateBeforeNavigatingToSearch != null)
            {
                SearchToggleStatus = (bool)_searchStateBeforeNavigatingToSearch;
                if (SearchToggleStatus)
                {
                    ShowSearchStuff();
                }
                else
                {
                    HideSearchStuff();
                }
            }

            switch (index)
            {
            case PageIndex.PageAnimeList:
                if (ViewModelLocator.AnimeList.Initializing)
                {
                    if (!_subscribed)
                    {
                        ViewModelLocator.AnimeList.Initialized += AnimeListOnInitialized;
                        _subscribed = true;
                    }
                    _postponedNavigationArgs = new Tuple <PageIndex, object>(originalIndex, args);
                    return;
                }
                switch ((args as AnimeListPageNavigationArgs)?.WorkMode ?? AnimeListWorkModes.Anime)
                {
                case AnimeListWorkModes.Anime:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.AnimeList);
                    break;

                case AnimeListWorkModes.SeasonalAnime:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.Seasonal);
                    break;

                case AnimeListWorkModes.Manga:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.MangaList);
                    break;

                case AnimeListWorkModes.TopAnime:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.TopAnime);
                    break;

                case AnimeListWorkModes.TopManga:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.TopManga);
                    break;

                case AnimeListWorkModes.AnimeByGenre:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.AnimeList);
                    break;

                case AnimeListWorkModes.AnimeByStudio:
                    ViewModelLocator.GeneralHamburger.SetActiveButton(HamburgerButtons.AnimeList);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                ShowSearchStuff();
                if ((_searchStateBeforeNavigatingToSearch == null || !_searchStateBeforeNavigatingToSearch.Value) &&
                    (wasOnSearchPage || _wasOnDetailsFromSearch))
                {
                    CurrentSearchQuery      = "";
                    _wasOnDetailsFromSearch = false;
                    UnToggleSearchStuff();
                }

                var alargs = args as AnimeListPageNavigationArgs;

                if (CurrentMainPage == PageIndex.PageAnimeList)
                {
                    ViewModelLocator.AnimeList.Init(args as AnimeListPageNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(new AnimeListPageFragment(args as AnimeListPageNavigationArgs));
                }

                if (alargs != null && (alargs.WorkMode == AnimeListWorkModes.Manga && alargs.ResetBackNav))
                {
                    ViewModelLocator.NavMgr.DeregisterBackNav();
                    ViewModelLocator.NavMgr.RegisterBackNav(PageIndex.PageAnimeList, null);
                }

                break;

            case PageIndex.PageAnimeDetails:
                HideSearchStuff();
                var detail = ViewModelLocator.AnimeDetails;
                detail.DetailImage = null;
                detail.LeftDetailsRow.Clear();
                detail.RightDetailsRow.Clear();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.AnimeDetails.RefreshData());
                _wasOnDetailsFromSearch = (args as AnimeDetailsPageNavigationArgs).Source == PageIndex.PageSearch;
                //from search , details are passed instead of being downloaded once more
                //if (CurrentMainPage == PageIndex.PageAnimeDetails)
                //    ViewModelLocator.AnimeDetails.Init(args as AnimeDetailsPageNavigationArgs);
                //else
                MainNavigationRequested?.Invoke(
                    new AnimeDetailsPageFragment(args as AnimeDetailsPageNavigationArgs));
                break;

            case PageIndex.PageSettings:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(new SettingsPageFragment(args as SettingsPageIndex?));
                break;

            case PageIndex.PageSearch:
            case PageIndex.PageMangaSearch:
            case PageIndex.PageCharacterSearch:
                if (CurrentMainPage != PageIndex.PageSearch && CurrentMainPage != PageIndex.PageMangaSearch &&
                    CurrentMainPage != PageIndex.PageCharacterSearch)
                {
                    _searchStateBeforeNavigatingToSearch = SearchToggleStatus;
                }

                if (args != null)
                {
                    var searchArg = args as SearchPageNavigationArgs;
                    if (string.IsNullOrWhiteSpace(searchArg.Query))
                    {
                        searchArg.Query = CurrentSearchQuery;
                    }
                    if (!searchArg.ByGenre && !searchArg.ByStudio)
                    {
                        //View.SearchInputFocus(FocusState.Keyboard);
                        SearchToggleLock = true;
                        ShowSearchStuff();
                        ToggleSearchStuff();
                    }
                    else
                    {
                        HideSearchStuff();
                        CurrentStatus = searchArg.ByGenre ? "Anime by Genre" : "Anime By Studio";
                    }
                }
                MainNavigationRequested?.Invoke(SearchPageFragment.BuildInstance(args as SearchPageNavigationArgs));
                break;

            case PageIndex.PageLogIn:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(LogInPageFragment.Instance);
                break;

            case PageIndex.PageProfile:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                if (Settings.SelectedApiType == ApiType.Mal)
                {
                    RefreshDataCommand =
                        new RelayCommand(
                            async() => await ViewModelLocator.ProfilePage.LoadProfileData(null, true));
                }
                if (Settings.SelectedApiType == ApiType.Mal)
                {
                    if (CurrentMainPage == PageIndex.PageProfile)
                    {
                        ViewModelLocator.ProfilePage.LoadProfileData(args as ProfilePageNavigationArgs);
                    }
                    else
                    {
                        MainNavigationRequested?.Invoke(new ProfilePageFragment(args as ProfilePageNavigationArgs));
                    }
                }
                break;

            case PageIndex.PageRecomendations:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(
                    new RecommendationsPageFragment(args as RecommendationPageNavigationArgs));
                break;

            case PageIndex.PageCalendar:
                HideSearchStuff();
                CurrentStatus           = "Calendar";
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.CalendarPage.Init(true); });
                MainNavigationRequested?.Invoke(CalendarPageFragment.Instance);
                break;

            case PageIndex.PageArticles:
            case PageIndex.PageNews:
                HideSearchStuff();
                MainNavigationRequested?.Invoke(new ArticlesPageFragment(args as MalArticlesPageNavigationArgs));
                break;

            case PageIndex.PageMessanging:
                HideSearchStuff();
                CurrentStatus =
                    $"{Credentials.UserName} - {(ViewModelLocator.MalMessaging.DisplaySentMessages ? "Sent Messages" : "Messages")}";
                //RefreshButtonVisibility = true;
                RefreshDataCommand = new RelayCommand(() => { ViewModelLocator.MalMessaging.Init(true); });
                MainNavigationRequested?.Invoke(new MessagingPageFragment());
                break;

            case PageIndex.PageMessageDetails:
                var msgModel = args as MalMessageDetailsNavArgs;
                CurrentOffStatus = msgModel.WorkMode == MessageDetailsWorkMode.Message
                        ? (msgModel.Arg != null
                            ? $"{(msgModel.Arg as MalMessageModel)?.Sender} - {(msgModel.Arg as MalMessageModel)?.Subject}"
                            : "New Message")
                        : $"Comments {Credentials.UserName} - {(msgModel.Arg as MalComment)?.User.Name}";
                MainNavigationRequested?.Invoke(new MessagingDetailsPageFragment(args as MalMessageDetailsNavArgs));
                break;

            case PageIndex.PageForumIndex:
                HideSearchStuff();
                CurrentStatus = "Forums";
                if (args == null || (args as ForumsNavigationArgs)?.Page == ForumsPageIndex.PageIndex)
                {
                    RefreshButtonVisibility = true;
                    RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsIndex.Init(true); });
                }
                else
                {
                    var navArgs = args as ForumsNavigationArgs;
                    if (navArgs?.Page == ForumsPageIndex.PageBoard)
                    {
                        RefreshButtonVisibility = true;
                        RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsBoard.Reload(); });
                    }
                    else if (navArgs?.Page == ForumsPageIndex.PageTopic)
                    {
                        RefreshButtonVisibility = true;
                        RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.ForumsTopic.Reload(); });
                    }
                }
                if (CurrentMainPage != null && CurrentMainPage == PageIndex.PageForumIndex)
                {
                    ViewModelLocator.ForumsMain.Init(args as ForumsNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(new ForumMainPageFragment(args as ForumsNavigationArgs));
                }
                break;

            case PageIndex.PageHistory:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => { ViewModelLocator.History.Init(null, true); });
                CurrentStatus           = $"History - {(args as HistoryNavigationArgs)?.Source ?? Credentials.UserName}";
                MainNavigationRequested?.Invoke(new HistoryPageFragment(args as HistoryNavigationArgs));
                break;

            case PageIndex.PageCharacterDetails:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.CharacterDetails.RefreshData());
                OffContentVisibility    = true;

                if (CurrentOffPage == PageIndex.PageCharacterDetails)
                {
                    ViewModelLocator.CharacterDetails.Init(args as CharacterDetailsNavigationArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(
                        new CharacterDetailsPageFragment(args as CharacterDetailsNavigationArgs));
                }
                break;

            case PageIndex.PageStaffDetails:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.StaffDetails.RefreshData());
                OffContentVisibility    = true;

                if (CurrentOffPage == PageIndex.PageStaffDetails)
                {
                    ViewModelLocator.StaffDetails.Init(args as StaffDetailsNaviagtionArgs);
                }
                else
                {
                    MainNavigationRequested?.Invoke(
                        new PersonDetailsPageFragment(args as StaffDetailsNaviagtionArgs));
                }
                break;

            case PageIndex.PageWallpapers:
                HideSearchStuff();
                RefreshButtonVisibility = false;
                MainNavigationRequested?.Invoke(new WallpapersPageFragment());
                break;

            case PageIndex.PagePopularVideos:
                HideSearchStuff();
                CurrentStatus = "Promotional Videos";
                MainNavigationRequested?.Invoke(new PromoVideosPageFragment());
                break;

            case PageIndex.PageFeeds:
                HideSearchStuff();
                //RefreshButtonVisibility = true;
                RefreshDataCommand = new RelayCommand(() => ViewModelLocator.FriendsFeeds.Init(true));
                CurrentStatus      = "Friends Feeds";
                MainNavigationRequested?.Invoke(new FriendsFeedsPageFragment());
                break;

            case PageIndex.PageNotificationHub:
                HideSearchStuff();
                //RefreshButtonVisibility = true;
                RefreshDataCommand = new RelayCommand(() => ViewModelLocator.NotificationsHub.Init(true));
                CurrentStatus      = "Notifications";
                MainNavigationRequested?.Invoke(new NotificationHubPageFragment());
                break;

            case PageIndex.PageListComparison:
                HideSearchStuff();
                CurrentStatus = "List Comparison";
                MainNavigationRequested?.Invoke(
                    new ListComparisonPageFragment(args as ListComparisonPageNavigationArgs));
                break;

            case PageIndex.PageFriends:
                HideSearchStuff();
                RefreshButtonVisibility = false;
                CurrentStatus           = $"{(args as FriendsPageNavArgs).TargetUser.Name}'s friends.";
                MainNavigationRequested?.Invoke(new FriendsPageFragment(args as FriendsPageNavArgs));
                break;

            case PageIndex.PageClubIndex:
                HideSearchStuff();
                RefreshButtonVisibility = false;
                CurrentStatus           = "Clubs";
                MainNavigationRequested?.Invoke(new ClubsIndexPageFragment());
                break;

            case PageIndex.PageClubDetails:
                HideSearchStuff();
                RefreshButtonVisibility = true;
                RefreshDataCommand      = new RelayCommand(() => ViewModelLocator.ClubDetails.Reload());
                CurrentStatus           = "Club details";
                MainNavigationRequested?.Invoke(new ClubDetailsPageFragment(args as ClubDetailsPageNavArgs));
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(index), index, null);
            }
            CurrentMainPage     = index;
            CurrentMainPageKind = index;
            RaisePropertyChanged(() => SearchToggleLock);
        }