private void InitializeData() { if (DesignMode.DesignModeEnabled) return; //when instantiating the collection, you pass it the task that gets more item, in this case it's "GetMoreData" //NOTE: This is for infinite items. if you have a max or total count, use the overload and pass the total as the 2nd parameter InfiniteItems = new IncrementalLoadingCollection<IncrementedItem>((cancellationToken, count) => Task.Run(GetMoreData, cancellationToken)); }
public void Initialize() { var repository = new DemoItemWebServiceRepository(); var source = new DemoItemRepositorySource(repository); _items = new IncrementalLoadingCollection<DemoItem>(source); _items.Loading += (s, e) => { SystemTray.Message = "読み込み中"; SystemTray.IsBusy = true; }; _items.Loaded += (s, e) => { SystemTray.IsBusy = false; }; }
private async Task LoadWall() { TaskStarted("wall"); try { var result = await _tracksService.GetWallPosts(ownerId : -Society.Id); _wallPostsTotalCount = result.TotalCount; WallPosts = new IncrementalLoadingCollection <AudioPost>(result.Posts ?? new List <AudioPost>()); WallPosts.HasMoreItemsRequested = () => WallPosts.Count > _wallPostsTotalCount; WallPosts.OnMoreItemsRequested = LoadMoreWallPosts; } catch (Exception ex) { Logger.Error(ex, "Unable to load society wall"); } TaskFinished("wall"); }
private async Task LoadPlaylists() { TaskStarted("playlists"); try { var result = await _tracksService.GetPlaylists(userId : -Society.Id, tracks : _tracks); _totalPlaylistsCount = result.TotalCount; Playlists = new IncrementalLoadingCollection <IPlaylist>(result.Playlists ?? new List <IPlaylist>()); Playlists.HasMoreItemsRequested = () => _totalPlaylistsCount > Playlists?.Count; Playlists.OnMoreItemsRequested = LoadMorePlaylists; } catch (Exception ex) { Logger.Error(ex, "Unable to load society playlists"); } TaskFinished("playlists"); }
public async Task FirstRequestFails() { var source = new DataSource <int>(AllData, DataSource <int> .ThrowException); var collection = new IncrementalLoadingCollection <DataSource <int>, int>(source, PageSize); await Assert.ThrowsExceptionAsync <AggregateException>(collection.LoadMoreItemsAsync(0).AsTask); Assert.IsTrue(!collection.Any()); var requests = new List <Task>(); for (int pageNum = 1; pageNum <= Pages; pageNum++) { requests.Add(collection.LoadMoreItemsAsync(0).AsTask() .ContinueWith(t => Assert.IsTrue(t.IsCompletedSuccessfully))); } await Task.WhenAll(requests); CollectionAssert.AreEqual(AllData, collection); }
private void GetEmails() { var collection = new IncrementalLoadingCollection <MicrosoftGraphSource <Microsoft.Graph.Message>, Microsoft.Graph.Message>( 10, async() => { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Loader.Visibility = Visibility.Visible; }); }, async() => { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Loader.Visibility = Visibility.Collapsed; }); }, async ex => { if (!Dispatcher.HasThreadAccess) { if (ex is ServiceException) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { NotConnectedMessage.Visibility = Visibility.Visible; Loader.Visibility = Visibility.Collapsed; //await DisplayAuthorizationErrorMessageAsync(ex as ServiceException, "Read user mail"); }); } else { throw ex; } } }); Mails.ItemsSource = collection; }
public async Task GetUserDetail() { try { Loading = true; var api = userCenterAPI.UserCenterDetail(mid); var results = await api.Request(); if (results.status) { var data = await results.GetData <UserCenterDetailModel>(); if (data.success) { UserCenterDetail = data.data; GetTopImage(); SubmitVideos = new IncrementalLoadingCollection <UserSubmitVideoSource, SubmitVideoItemModel>(new UserSubmitVideoSource(mid), 30); } else { Utils.ShowMessageToast(data.message); } } else { Utils.ShowMessageToast(results.message); } } catch (Exception ex) { var handel = HandelError(ex); Utils.ShowMessageToast(handel.message); } finally { Loading = false; } }
public ForumViewModel(Forum forum, ApiConfig config) { Name = forum.Name; ID = forum.Id; Posts = new IncrementalLoadingCollection <PostLoader, PostViewModel>( new PostLoader(this, config), () => { _onError = false; FooterText = Bible.OnLoading; RefreshCommand.RaiseCanExecuteChanged(); } , () => { if (!_onError) { FooterText = Bible.OnFinished; } RefreshCommand.RaiseCanExecuteChanged(); }, (ex) => { FooterText = Bible.OnError; _onError = true; RefreshCommand.RaiseCanExecuteChanged(); }); RefreshCommand = new RelayCommand(() => { if (_onError) { Posts.RetryFailed(); } else { Posts.RefreshAsync(); } }, () => !Posts.IsLoading, true); }
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state) { if ((parameter as string) != _query) { _query = parameter as string; var loading = Window.Current.Content as LoadingView; _searchSource = new SearchSource(_query, () => { loading.IsLoading = true; }, () => { loading.IsLoading = false; }); SearchList = new IncrementalLoadingCollection <SearchSource, SearchResult>(_searchSource, onError: (ex) => { loading.IsLoading = false; }); } return(Task.CompletedTask); }
public UsersViewModel(IScreen screen) : base(screen) { Add = ReactiveCommand.Create(AddAction); this.WhenActivated(d => { Users = new IncrementalLoadingCollection <UserSource, User>(); ReactiveFactory.UserChanged += ReactiveFactory_UserChanged; this.WhenAnyValue(x => x.SelectedUser) .WhereNotNull().Subscribe(s => { HostScreen.Router.Navigate.Execute(new TestListViewModel(HostScreen, SelectedUser)); SelectedUser = null; }); Disposable .Create(() => { ReactiveFactory.UserChanged -= ReactiveFactory_UserChanged; }) .DisposeWith(d); }); }
public async Task EveryOtherRequestFails() { var source = new DataSource <int>(AllData, FailPassSequence); var collection = new IncrementalLoadingCollection <DataSource <int>, int>(source, PageSize); var willFail = true; for (int submitedRequests = 0; submitedRequests < Pages * 2; submitedRequests++) { if (willFail) { await Assert.ThrowsExceptionAsync <AggregateException>(collection.LoadMoreItemsAsync(0).AsTask); } else { await collection.LoadMoreItemsAsync(0); } willFail = !willFail; } CollectionAssert.AreEqual(AllData, collection); }
public MoviePageViewModel() { MovieListCollection = new IncrementalLoadingCollection <MovieListModel>(CommonDataLoader.GetMovieListModel); #if DEBUG if (DesignMode.DesignModeEnabled) { MovieListCollection.Add(new MovieListModel { Cover = "ms-appx:///Resources/Test/cover.png", Id = "34", Title = "卧虎藏龙2:青冥宝剑", Score = "39" }); MovieListCollection.Add(new MovieListModel { Cover = "ms-appx:///Resources/Test/cover.png", Id = "34", Title = "卧虎藏龙2:青冥宝剑", Score = "39" }); } #endif }
/// <summary> /// Initializes a new instance of the <see cref="ProfileViewModel" /> class. /// </summary> /// <param name="navigationFacade">The navigation facade.</param> /// <param name="photoService">The photo service.</param> /// <param name="dialogService">The dialog service.</param> public ProfileViewModel(INavigationFacade navigationFacade, IPhotoService photoService, IDialogService dialogService) { _navigationFacade = navigationFacade; _photoService = photoService; _dialogService = dialogService; Photos = new IncrementalLoadingCollection<Photo>(s => { Func<Task<PagedResponse<Photo>>> f = async () => { if (IsShowingCurrentUser) { var stream = await photoService.GetPhotosForCurrentUser(s); return stream; } return await photoService.GetPhotosForUser(User, s); }; return f(); }, async () => await _dialogService.ShowGenericServiceErrorNotification(), OnPhotosLoadingFinished); // Photos collection is being loaded asynchronously, so we need to // watch it to see if the user has any pictures uploaded already. Photos.CollectionChanged += PhotosCollectionChanged; // Initialize commands PhotoSelectedCommand = new RelayCommand<Photo>(OnPhotoSelected); DeletePhotoCommand = new RelayCommand<Photo>(OnDeletePhoto); SetProfilePhotoCommand = new RelayCommand<Photo>(OnSetProfilePhoto); // Before pictures are retrieved from the service, // we want to prevent an initial notification showing up // that the user has no pictures. ArePhotosEmpty = false; }
/// <summary> /// Initializes a new instance of the <see cref="ProfileViewModel" /> class. /// </summary> /// <param name="navigationFacade">The navigation facade.</param> /// <param name="photoService">The photo service.</param> /// <param name="dialogService">The dialog service.</param> public ProfileViewModel(INavigationFacade navigationFacade, IPhotoService photoService, IDialogService dialogService) { _navigationFacade = navigationFacade; _photoService = photoService; _dialogService = dialogService; Photos = new IncrementalLoadingCollection <Photo>(s => { Func <Task <PagedResponse <Photo> > > f = async() => { if (IsShowingCurrentUser) { var stream = await photoService.GetPhotosForCurrentUser(s); return(stream); } return(await photoService.GetPhotosForUser(User, s)); }; return(f()); }, async() => await _dialogService.ShowGenericServiceErrorNotification(), OnPhotosLoadingFinished); // Photos collection is being loaded asynchronously, so we need to // watch it to see if the user has any pictures uploaded already. Photos.CollectionChanged += PhotosCollectionChanged; // Initialize commands PhotoSelectedCommand = new RelayCommand <Photo>(OnPhotoSelected); DeletePhotoCommand = new RelayCommand <Photo>(OnDeletePhoto); SetProfilePhotoCommand = new RelayCommand <Photo>(OnSetProfilePhoto); // Before pictures are retrieved from the service, // we want to prevent an initial notification showing up // that the user has no pictures. ArePhotosEmpty = false; }
private void SearchQueryCommandExecute(object args) { try { if (args is AutoSuggestBoxQuerySubmittedEventArgs) { var queryText = (args as AutoSuggestBoxQuerySubmittedEventArgs).QueryText; var flickrConfig = new FlickrDataConfig() { QueryType = FlickrQueryType.Search, Query = queryText }; Reset(); PhotoCollection = new IncrementalLoadingCollection <Photo>((cancellationToken, count) => Task.Run(() => GetFlickrPhotos(flickrConfig), cancellationToken)); } } catch (Exception ex) { AppLogs.WriteError("[SearchQueryCommandExecute]", ex.ToString()); } }
private async void AvailabilityChanged(ConnectionTypes connectionTypes) { try { var networkAvailabilityStatus = await _networkAvailableService.IsInternetAvailable(); if (IsNetworkAvailable != networkAvailabilityStatus) { IsNetworkAvailable = networkAvailabilityStatus; if (IsNetworkAvailable) { _pageIndex = 0; PhotoCollection = new IncrementalLoadingCollection <Photo>((cancellationToken, count) => Task.Run(() => GetFlickrPhotos(new FlickrDataConfig()), cancellationToken)); } } } catch (Exception ex) { AppLogs.WriteError("[AvailabilityChanged]", ex.ToString()); } }
private async void GetEventsButton_Click(object sender, RoutedEventArgs e) { if (!await Tools.CheckInternetConnectionAsync()) { return; } int top = 10; var collection = new IncrementalLoadingCollection <MicrosoftGraphSource <Event>, Event>( top, async() => { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Shell.Current.DisplayWaitRing = true; }); }, async() => { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Shell.Current.DisplayWaitRing = false; }); }, async ex => { if (!Dispatcher.HasThreadAccess) { if (ex is ServiceException) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { await DisplayAuthorizationErrorMessageAsync(ex as ServiceException, "Read user event"); }); } else { throw ex; } } }); EventsList.ItemsSource = collection; }
public async Task <bool> RefreshAsync() { try { if (DataList.IsBusy) { return(false); } PageIndex = DEFAULT_PAGE_INDEX; if (DataList == null) { DataList = new IncrementalLoadingCollection <T>(count => { return(GetIncrementalListData(PageIndex++)); }); } else { //DataList.DataFetchDelegate = (c => // { // return GetIncrementalListData(PageIndex++); // }); } await DataList.LoadMoreItemsAsync(20u); return(true); } catch (Exception e) { var task = Logger.LogAsync(e); return(false); } }
private void LoadJokeInfoCollection(JokeAPI jokeAPI) { JokeInfoCollection = new IncrementalLoadingCollection<JokeInfo>( async (pageIndex, requestCount) => { IsBusy = !IsDisConnected; PageIndex = pageIndex; JokeResponse<JokeInfo> tempJokeResponse = await JokeAPIUtils.GetJokeInfoList<JokeInfo>(new RequestParam { jokeAPI = jokeAPI, page = pageIndex, count = requestCount, token = JokeAPIUtils.UserLoginInfo.token, args = UserInfo == null ? null : new string[] { UserInfo.id } }); IsBusy = false; return tempJokeResponse; }, (jokeInfo) => { return JokeInfoCollection.FirstOrDefault(joke => joke.id == jokeInfo.id) != null; }); _JokeInfoCollection.OnLoadStatusChanged += _JokeInfoCollection_OnLoadStatusChanged; _JokeInfoCollection.OnNetworkStatusChanged += _JokeInfoCollection_OnNetworkStatusChanged; }
/// <summary> /// Stößt den Abonnementvorgang an. Der lokale Nutzer abonniert den Kanal, der aktuell /// in der Detailansicht angezeigt wird. /// </summary> private async Task executeSubscribeChannel() { try { displayIndeterminateProgressIndicator(); await channelController.SubscribeChannelAsync(Channel.Id); //Setze Kanal als abonniert. ChannelSubscribedStatus = true; if (ChannelSubscribedStatus && !Channel.Deleted) { CanUnsubscribeChannel = true; } else { CanUnsubscribeChannel = false; } // Lade Moderatoren-Info. await LoadModeratorsOfChannelAsync(); // Bleibe auf der Seite, aber lade die Nachrichten nach. List<Announcement> announcements = await Task.Run(() => channelController.GetAllAnnouncementsOfChannel(Channel.Id)); // Setze PageSize auf 0, d.h. lade keine Elemente nach. Announcements = new IncrementalLoadingCollection<IncrementalAnnouncementLoaderController, Announcement>(Channel.Id, 0); await Announcements.LoadExistingCollectionAsync(announcements); } catch(ClientException ex) { // Markiere Kanal in lokaler Liste als gelöscht, wenn er nicht auf dem Server gefunden wurde. if(ex.ErrorCode == ErrorCodes.ChannelNotFound) { // Passe View an. Channel.Deleted = true; checkCommandExecution(); } displayError(ex.ErrorCode); } finally { hideIndeterminateProgressIndicator(); } }
private async Task Reset() { if (Mylist.Value == null) { return; } CanEditMylist = false; var mylistOrigin = Mylist.Value?.ToMylistOrigin(); IsLoginUserDeflist = false; IsWatchAfterLocalMylist = Mylist.Value is Interfaces.ILocalMylist && Mylist.Value?.Id == HohoemaPlaylist.WatchAfterPlaylistId; IsUserOwnerdMylist = Mylist.Value is Interfaces.IUserOwnedMylist; IsLocalMylist = Mylist.Value is Interfaces.ILocalMylist; IsLoginUserMylistWithoutDeflist = false; MaxItemsCount = Mylist.Value.ItemCount; RaisePropertyChanged(nameof(MaxItemsCount)); switch (mylistOrigin) { case PlaylistOrigin.LoginUser: { var mylistGroup = UserMylistManager.GetMylistGroup(Mylist.Value.Id); MylistItems = mylistGroup.ToReadOnlyReactiveCollection(x => new MylistVideItemViewModel(x, mylistGroup)) .AddTo(_NavigatingCompositeDisposable); MylistTitle = mylistGroup.Label; MylistDescription = mylistGroup.Description; ThemeColor = mylistGroup.IconType.ToColor(); IsPublic = mylistGroup.IsPublic; IsLoginUserDeflist = mylistGroup.IsDeflist; OwnerUserId = mylistGroup.UserId; UserName = NiconicoSession.UserName; CanEditMylist = !IsLoginUserDeflist; if (IsLoginUserDeflist) { MylistState = "とりあえずマイリスト"; DeflistRegistrationCapacity = UserMylistManager.DeflistRegistrationCapacity; DeflistRegistrationCount = UserMylistManager.DeflistRegistrationCount; } else { IsLoginUserMylistWithoutDeflist = true; MylistState = IsPublic ? "公開マイリスト" : "非公開マイリスト"; MylistRegistrationCapacity = UserMylistManager.MylistRegistrationCapacity; MylistRegistrationCount = UserMylistManager.MylistRegistrationCount; } } break; case PlaylistOrigin.OtherUser: var otherOwnedMylist = Mylist.Value as OtherOwneredMylist; MylistItems = new IncrementalLoadingCollection <OtherOwnedMylistIncrementalSource, MylistVideItemViewModel>(new OtherOwnedMylistIncrementalSource(otherOwnedMylist, MylistProvider, NgSettings)); var response = await MylistProvider.GetMylistGroupDetail(Mylist.Value.Id); var mylistGroupDetail = response.MylistGroup; MylistTitle = otherOwnedMylist.Label; MylistDescription = otherOwnedMylist.Description; IsPublic = true; //ThemeColor = mylistGroupDetail.GetIconType().ToColor(); OwnerUserId = mylistGroupDetail.UserId; MylistState = IsPublic ? "公開マイリスト" : "非公開マイリスト"; var user = Database.NicoVideoOwnerDb.Get(OwnerUserId); if (user != null) { UserName = user.ScreenName; } else { var userDetail = await UserProvider.GetUser(OwnerUserId); UserName = userDetail.ScreenName; } CanEditMylist = false; break; case PlaylistOrigin.Local: { var localMylist = Mylist.Value as LocalMylistGroup; MylistItems = localMylist.ToReadOnlyReactiveCollection(x => new MylistVideItemViewModel(x, localMylist)) .AddTo(_NavigatingCompositeDisposable); MylistTitle = Mylist.Value.Label; OwnerUserId = NiconicoSession.UserId.ToString(); UserName = NiconicoSession.UserName; MylistState = "ローカル"; CanEditMylist = !IsWatchAfterLocalMylist; } break; default: break; } RaisePropertyChanged(nameof(MylistItems)); EditMylistGroupCommand.RaiseCanExecuteChanged(); DeleteMylistCommand.RaiseCanExecuteChanged(); }
async void LoadCommands() { await StopCommandsSubscription(); bool loaded = false; CommandFilter filter = new CommandFilter() { End = filterCommandsEnd, Start = filterCommandsStart, SortOrder = SortOrder.DESC }; var list = new IncrementalLoadingCollection<Command>(async (take, skip) => { filter.Skip = (int)skip; filter.Take = (int)take; try { Debug.WriteLine("CMD LOAD START"); var commands = await ClientService.Current.GetCommandsAsync(deviceId, filter); Debug.WriteLine("CMD LOAD END"); return commands; } catch (Exception ex) { Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { new MessageDialog(ex.Message, "Error").ShowAsync(); }); throw ex; } }, 20); list.IsLoadingChanged += (s, isLoading) => { LoadingItems += isLoading ? 1 : -1; if (!isLoading && !loaded) { StartCommandsSubscription(); if (s.Count > 0) { // makes server response faster filter.End = s.First().Timestamp; } loaded = true; } }; CommandsObservable = list; }
public Album() { photos = new IncrementalLoadingCollection <PhotosSource, Photo>(10); this.InitializeComponent(); }
// If you have install the code sniplets, use "propvm + [tab] +[tab]" create a property。 // 如果您已经安装了 MVVMSidekick 代码片段,请用 propvm +tab +tab 输入属性 public AuthorListPage_Model() { AuthorListAuthor = new IncrementalLoadingCollection <AuthorSource, Author>("", AppStrings.PageSize); Title = "zhuanlan"; }
public ViewModel() { Items = new IncrementalLoadingCollection(); }
public void Initialize() { var repository = new DemoItemStaticRepository(); var source = new DemoItemRepositorySource(repository); _items = new IncrementalLoadingCollection<DemoItem>(source); }
private void LoadAllUserPerformedEvents(string login) { UserPerformedActivitySource source = new UserPerformedActivitySource(login); allUserPerformedEvents = new IncrementalLoadingCollection <UserPerformedActivitySource, Activity>(source); }
public void LoadAllCurrentUserFollowings() { allCurrentUserFollowings = new IncrementalLoadingCollection <CurrentUserFollowings, Octokit.User>(); }
public void LoadAllCurrentUserPerformedEvents() { allCurrentUserPerformedEvents = new IncrementalLoadingCollection <CurrentUserPerformedActivitySource, Activity>(); }
public void Initialize() { System.Diagnostics.Debug.WriteLine("GridViewAndNavigationMainViewModel.Initialize"); var repository = new DemoItemStaticRepository(); var source = new DemoItemRepositorySource(repository); _items = new IncrementalLoadingCollection<DemoItem>(source); }
//---------------------------------------------------------------------- public void Init() { Games = new IncrementalLoadingCollection<Game>( GetGames, TimeSpan.FromSeconds( 30 ) ); RaisePropertyChanged( () => Games ); }
protected override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); selectedSubreddit = e.Parameter as Subreddit; Posts = new IncrementalLoadingCollection <SubredditPostSource, Post>(selectedSubreddit); }
public NukiLockStatusPartViewModel() { LockHistory = null; }
public MainViewModel(IGithubService service) { _repositoriesSource = new GithubIncrementalItemSource(service); Repositories = new IncrementalLoadingCollection<Repository, GithubIncrementalItemSource>(_repositoriesSource); }
public ScriptGalleryViewModel(ScriptApi api) { Api = api; _loadFunc = page => Api.Home(page); Source = new IncrementalLoadingCollection <IIncrementalSource <IGallery>, IGallery>(this, onError: OnLoadError, onStartLoading: OnStartLoading, onEndLoading: OnEndLoading); }
/// <summary> /// Lädt die Daten des Kanals mit der übergebenen Id in das ViewModel /// und macht die Daten über die Properties verfügbar. /// </summary> /// <param name="selectedChannelId">Die Id des Kanals, der geladen werden soll.</param> public void LoadSelectedChannel(int selectedChannelId) { try { Channel = channelController.GetChannel(selectedChannelId); } catch (ClientException ex) { // Zeige Fehlernachricht an. displayError(ex.ErrorCode); } if (Channel != null) { switch (Channel.Type) { case ChannelType.LECTURE: Debug.WriteLine("Selected channel is of type Lecture."); Lecture = Channel as Lecture; break; case ChannelType.EVENT: Debug.WriteLine("Selected channel is of type Event."); EventObj = Channel as Event; break; case ChannelType.SPORTS: Debug.WriteLine("Selected channel is of type Sports."); Sports = Channel as Sports; break; default: Debug.WriteLine("Selected channel is of type Student_Group or Other with no special properties."); break; } } // Initialisiere asynchrones Announcement Laden. Announcements = new IncrementalLoadingCollection<IncrementalAnnouncementLoaderController, Announcement>(selectedChannelId, 20); checkCommandExecution(); }
protected async Task ResetList() { using (var releaser = await _ItemsUpdateLock.LockAsync()) { HasItem.Value = true; LoadedItemsCount.Value = 0; IsSelectionModeEnable.Value = false; SelectedItems.Clear(); if (IncrementalLoadingItems != null) { if (IncrementalLoadingItems.Source is HohoemaIncrementalSourceBase <ITEM_VM> ) { (IncrementalLoadingItems.Source as HohoemaIncrementalSourceBase <ITEM_VM>).Error -= HohoemaIncrementalSource_Error; } IncrementalLoadingItems.BeginLoading -= BeginLoadingItems; IncrementalLoadingItems.DoneLoading -= CompleteLoadingItems; IncrementalLoadingItems.Dispose(); IncrementalLoadingItems = null; RaisePropertyChanged(nameof(IncrementalLoadingItems)); } try { var source = GenerateIncrementalSource(); if (source == null) { HasItem.Value = false; return; } MaxItemsCount.Value = await source.ResetSource(); IncrementalLoadingItems = new IncrementalLoadingCollection <IIncrementalSource <ITEM_VM>, ITEM_VM>(source); RaisePropertyChanged(nameof(IncrementalLoadingItems)); IncrementalLoadingItems.BeginLoading += BeginLoadingItems; IncrementalLoadingItems.DoneLoading += CompleteLoadingItems; if (IncrementalLoadingItems.Source is HohoemaIncrementalSourceBase <ITEM_VM> ) { (IncrementalLoadingItems.Source as HohoemaIncrementalSourceBase <ITEM_VM>).Error += HohoemaIncrementalSource_Error; } ItemsView.Source = IncrementalLoadingItems; RaisePropertyChanged(nameof(ItemsView)); PostResetList(); } catch { IncrementalLoadingItems = null; NowLoading.Value = false; HasItem.Value = true; HasError.Value = true; Debug.WriteLine("failed GenerateIncrementalSource."); } } }
public MainViewModel(IGithubService service) { _repositoriesSource = new GithubIncrementalItemSource(service); Repositories = new IncrementalLoadingCollection <Repository, GithubIncrementalItemSource>(_repositoriesSource); }
private async Task ListFilesFolders(string path) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { // update the title path if (path == "/") { pathText.Text = "CloudStreamer"; } else { pathText.Text = path; } fileScrollViewer.Visibility = Visibility.Collapsed; progressRing.Visibility = Visibility.Visible; progressRing.IsActive = true; }); // handle login try { await UpdateOrInitOneDriveAuthIfNecessary(); } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e, "error"); try { await ExitOrRetryWithMessage("Failed to authenticate with OneDrive. Error: " + e.ToString()); } catch (Exception ex) { Crashes.TrackError(ex, new Dictionary <string, string> { { "On", "Call Error Dialog" }, { "Where", "MainPage.xaml:InitOneDrive" }, { "DueTo", e.Message } }); } return; } if (oneDriveClient == null) { return; } try { IItemChildrenCollectionRequest request; if (path == "/") { request = oneDriveClient.Drive.Root.Children.Request(); } else { request = oneDriveClient.Drive.Root.ItemWithPath(path).Children.Request(); } IItemChildrenCollectionRequest sortedRequest = request.OrderBy(currentSortBy + " " + currentSortByDir); sortedRequest = sortedRequest.Expand("thumbnails"); files = (ItemChildrenCollectionPage)await sortedRequest.GetAsync(); } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e, "error"); try { await ExitOrRetryWithMessage("Failed to load Files from OneDrive. Error: " + e.ToString()); } catch (Exception ex) { Crashes.TrackError(ex, new Dictionary <string, string> { { "On", "Call Error Dialog" }, { "Where", "MainPage.xaml:ListFilesFolders" }, { "DueTo", e.Message } }); } } await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { fileItems = new IncrementalLoadingCollection(files); fileScrollViewer.ItemsSource = fileItems; loading = false; progressRing.IsActive = false; progressRing.Visibility = Visibility.Collapsed; fileScrollViewer.Visibility = Visibility.Visible; }); System.Diagnostics.Debug.WriteLine("Got " + fileItems.Count() + " files"); }
/// <summary> /// Initializes a new instance of the <see cref="StreamViewModel" /> class. /// </summary> /// <param name="navigationFacade">The navigation facade.</param> /// <param name="photoService">The photo service.</param> /// <param name="authEnforcementHandler">the authentication enforcement handler</param> /// <param name="dialogService">The dialog service.</param> public StreamViewModel(INavigationFacade navigationFacade, IPhotoService photoService, IAuthEnforcementHandler authEnforcementHandler, IDialogService dialogService) { _navigationFacade = navigationFacade; _authEnforcementHandler = authEnforcementHandler; _dialogService = dialogService; Photos = new IncrementalLoadingCollection<Photo>(s => { Func<Task<PagedResponse<Photo>>> f = async () => { var stream = await photoService.GetPhotosForCategoryId(Category.Id, s); if (SelectedPhotoThumbnail != null && SelectedPhoto == null) { SelectedPhoto = stream.Items.FindPhotoForThumbnail(SelectedPhotoThumbnail); } return stream; }; return f(); }, async () => await _dialogService.ShowGenericServiceErrorNotification()); // Initialize commands RefreshCommand = new RelayCommand(OnRefresh); GotoCameraCommand = new RelayCommand(OnGotoCamera); GiveGoldCommand = new RelayCommand<Photo>(OnGiveGold); PhotoSelectedCommand = new RelayCommand<Photo>(OnPhotoSelected); ContributeCommand = new RelayCommand(OnGotoCamera); UserSelectedCommand = new RelayCommand<User>(OnUserSelected); }
public void HasMoreItems_IsTrueByDefault() { var collection = new IncrementalLoadingCollection <object>(Mock.Create <IVirtualisedDataSource <object> >()); Assert.Equal(true, collection.HasMoreItems); }
private void LoadAllUserFollowers(string login) { UserFollowersSource source = new UserFollowersSource(login); allUserFollowers = new IncrementalLoadingCollection <UserFollowersSource, Octokit.User>(source); }
/// <summary> /// Lädt die Daten des Kanals mit der übergebenen Id in das ViewModel /// und macht die Daten über die Properties verfügbar. /// </summary> /// <param name="selectedChannelId">Die Id des Kanals, der geladen werden soll.</param> public void LoadSelectedChannel(int selectedChannelId) { try { Channel = channelController.GetChannel(selectedChannelId); } catch(ClientException ex) { // Zeige Fehlernachricht an. displayError(ex.ErrorCode); } if(Channel != null) { switch (Channel.Type) { case ChannelType.LECTURE: Debug.WriteLine("Selected channel is of type Lecture."); Lecture = Channel as Lecture; break; case ChannelType.EVENT: Debug.WriteLine("Selected channel is of type Event."); EventObj = Channel as Event; break; case ChannelType.SPORTS: Debug.WriteLine("Selected channel is of type Sports."); Sports = Channel as Sports; break; default: Debug.WriteLine("Selected channel is of type Student_Group or Other with no special properties."); break; } // Prüfe, ob Kanal bereits abonniert wurde. ChannelSubscribedStatus = channelController.IsChannelSubscribed(Channel.Id); if (ChannelSubscribedStatus && !Channel.Deleted) { CanUnsubscribeChannel = true; } else { CanUnsubscribeChannel = false; } if(ChannelSubscribedStatus == true) { // Aktiviere dynamisches Laden der Announcements. // Es sollen mindestens immer alle noch nicht gelesenen Nachrichten geladen werden, immer aber mindestens 20. int numberOfItems = Channel.NumberOfUnreadAnnouncements; if(numberOfItems < 20) { numberOfItems = 20; } Debug.WriteLine("Call constructor of IncrementalLoadingCollection. Selected channel id is {0}.", selectedChannelId); Announcements = new IncrementalLoadingCollection<IncrementalAnnouncementLoaderController, Announcement>(selectedChannelId, numberOfItems); } checkCommandExecution(); } }