private void OnLibraryUpdated(string s) { DispatcherHelper.CheckBeginInvokeOnUI(() => { Artists.Clear(); LoadArtists(); }); }
public async Task Initialize() { Artists.Clear(); Albums.Clear(); Tracks.Clear(); TrackCollections.Clear(); Videos.Clear(); CameraRoll.Clear(); Shows.Clear(); if (_alreadyIndexedOnce) { return; } _alreadyIndexedOnce = true; // Doing full indexing from scratch if 0 tracks are found if (IsMusicDatabaseEmpty() && IsVideoDatabaseEmpty()) { ClearDatabase(); } else // Restore the database { LoadVideosFromDatabase(); await LoadShowsFromDatabase(); LoadCameraRollFromDatabase(); } await PerformMediaLibraryIndexing(); }
/// <summary> /// Retrieves songs from the data source. /// </summary> public async void LoadSongs() { await DispatcherHelper.ExecuteOnUIThreadAsync(() => { Songs.Clear(); Artists.Clear(); Albums.Clear(); }); var songs = App.Repository.GetAll(); var artists = App.Repository.GetArtists(); var albums = App.Repository.GetAlbums(); await DispatcherHelper.ExecuteOnUIThreadAsync(() => { foreach (var song in songs) { Songs.Add(song); } foreach (var artist in artists) { Artists.Add(artist); } foreach (var album in albums) { Albums.Add(album); } }); }
public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState) { Tracks = Tracks ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverTrack> >(LoadTracks); Artists = Artists ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverArtist> >(LoadArtists); Albums = Albums ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverAlbum> >(LoadAlbums); Genres = Genres ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverGenre> >(LoadGenres); Folders = Folders ?? new SimpleStateSupportCollection <VKSaverFolder>(LoadFolders); Cached = Cached ?? new SimpleStateSupportCollection <JumpListGroup <VKSaverTrack> >(LoadCachedTracks); if (_libraryDatabaseService.NeedReloadLibraryView) { Tracks.Clear(); Artists.Clear(); Albums.Clear(); Genres.Clear(); Folders.Clear(); Cached.Clear(); _libraryDatabaseService.NeedReloadLibraryView = false; } if (viewModelState.Count > 0) { CurrentPivotIndex = (int)viewModelState[nameof(CurrentPivotIndex)]; } else { string viewName = (string)e.Parameter; SetPivotIndex(viewName); } base.OnNavigatedTo(e, viewModelState); }
void ClearDatabase() { musicDatabase.DeleteAll(); musicDatabase.DeleteAll(); musicDatabase.DeleteAll(); trackCollectionRepository.DeleteAll(); tracklistItemRepository.DeleteAll(); musicDatabase.Initialize(); musicDatabase.Initialize(); musicDatabase.Initialize(); trackCollectionRepository.Initialize(); tracklistItemRepository.Initialize(); Artists.Clear(); Albums.Clear(); Tracks.Clear(); TrackCollections.Clear(); videoDatabase.DeleteAll(); Videos.Clear(); CameraRoll.Clear(); Shows.Clear(); }
private void OnTableSelectionChanged(object sender, RoutedEventArgs e) { string selected = TableSelectComboBox.SelectedValue.ToString(); if (selected.Equals("Tracks")) { LastNameTextBox.IsEnabled = false; YearTextBox.IsEnabled = false; GenreNameTextBox.IsEnabled = false; DataTable artists = dm.runSelectQuery("select Artists.FirstName from Artists"); Artists.Clear(); foreach (DataRow row in artists.Rows) { Artists.Add(row["FirstName"] as string); } ArtistSelectComboBox.ItemsSource = Artists; DataTable albums = dm.runSelectQuery("select Albums.AlbumName from Albums"); Albums.Clear(); foreach (DataRow row in albums.Rows) { Albums.Add(row["AlbumName"] as string); } AlbumSelectComboBox.ItemsSource = Albums; } }
public void ResetMusicContent() { Tracks.Clear(); Albums.Clear(); Artists.Clear(); Playlists.Clear(); }
public void Clear() { Artists.Clear(); Albums.Clear(); Geneires.Clear(); Years.Clear(); }
public void LoadArtistsFromDatabase() { Artists.Clear(); LogHelper.Log("Loading artists from MusicDB ..."); var artists = LoadArtists(null); LogHelper.Log("Found " + artists.Count + " artists from MusicDB"); Artists.AddRange(artists.OrderBy(x => x.Name).ToObservable()); }
private void PopulateArtists() { Artists.Clear(); foreach (string artist in m_DataModel.Database.Artists) { Artists.Add(new MusicCollectionItem(artist, Artists.Count)); } }
public override void Cleanup() { _artistsLoaded = _albumsLoaded = _songsLoaded = _genresLoaded = false; _parentId = null; Genres.Clear(); Songs.Clear(); Artists.Clear(); Albums.Clear(); SelectedTracks.Clear(); base.Cleanup(); }
private async void Refresh() { await ServiceLocator.LocalMusicService.Clear(); if (Tracks != null) { Tracks.Clear(); } if (Artists != null) { Artists.Clear(); } if (Albums != null) { Albums.Clear(); } if (AlbumGroups != null) { AlbumGroups.Clear(); } if (SelectedArtistAlbums != null) { SelectedArtistAlbums.Clear(); } var flyout = new FlyoutControl(); flyout.FlyoutContent = new MusicScanView(); await flyout.ShowAsync(); switch (SelectedTabIndex) { case 0: LoadTracks(); break; case 1: LoadAlbums(); break; case 2: LoadArtists(); break; } }
private void LoadArtists() { Artists.Clear(); IList <Artist> artists = administrationService.GetArtists(); foreach (Artist artist in artists) { Artists.Add(new ArtistVM(artist, this.administrationService, ioService)); } CurrentArtist = Artists.First(); var view = CollectionViewSource.GetDefaultView(Artists); view.GroupDescriptions.Clear(); view.GroupDescriptions.Add(new PropertyGroupDescription("Catagory.Name")); }
public void Rebuild(IEnumerable <Song> songs) { Albums.Clear(); Artists.Clear(); Years.Clear(); Geneires.Clear(); foreach (var s in songs) { Albums.Add(s.Album); Artists.Add(s.Artist); Years.Add(s.Year.ToString()); Geneires.Add(s.Genre); } }
private async Task LoadFromDatabase() { await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Artists.Clear(); Tracks.Clear(); }); await MusicLibraryManagement.LoadFromSQL(); await DispatchHelper.InvokeAsync(() => { IsMusicLibraryEmpty = !Artists.Any(); OnPropertyChanged("IsMusicLibraryEmpty"); }); }
public void PopulateArtists(string artistsText) { Artists.Clear(); if (!string.IsNullOrEmpty(artistsText)) { artistsText.Split('|').ToList().ForEach(artist => { if (!string.IsNullOrEmpty(artist)) { Artists.Add(new ArtistItem(Container) { Add = true, ArtistName = artist }); } }); } }
private async void SearchArtists(string query) { Artists.Clear(); List <int> foundArtists = await SearchManagerModel.SearchArtists(query); foreach (int artistId in foundArtists) { ArtistViewModel foundArtist = LibraryViewModel.Current.LookupArtistById(artistId); if (foundArtist != null) { Artists.Add(foundArtist); } } artistSearchInProgress = false; NotifyPropertyChanged(Properties.SearchInProgress); NotifyPropertyChanged(Properties.ContentInfoArtists); }
async Task ExecuteLoadCommand() { if (IsBusy) { return; } IsBusy = true; Artists.Clear(); await Task.Delay(3000); foreach (Artist a in ArtistsToLoad) { Artists.Add(a); } IsBusy = false; }
public void ClearCollection() { Artists.Clear(); Genres.Clear(); Directories.Clear(); Songs.Clear(); m_AlbumLookup.Clear(); m_GenreFilteredAlbumLookup.Clear(); m_ArtistExpansion = new SortedDictionary <LibraryItem, ISet <Album> >(); m_AlbumExpansion = new SortedDictionary <LibraryItem, ISet <Song> >(); m_GenreExpansion = new SortedDictionary <LibraryItem, ISet <GenreFilteredAlbum> >(); m_GenreFilteredAlbumExpansion = new SortedDictionary <LibraryItem, ISet <Song> >(); m_DirectoryExpansion = new SortedDictionary <LibraryItem, ISet <LibraryItem> >(); m_ArtistExpansion.Clear(); m_AlbumExpansion.Clear(); m_GenreExpansion.Clear(); m_GenreFilteredAlbumExpansion.Clear(); NotifyPropertyChanged("Database"); }
/// <summary> /// Populates the list of artists refer to query /// </summary> /// <param name="query">string variable to artist searching</param> /// <returns></returns> public async Task _SearchArtists(string query) { try { IsLoading = true; var artistList = await SpotifyAPI.GetArtists(query.ToLower()); if (artistList != null && artistList.Count > 0) { Artists.Clear(); foreach (Artist artist in artistList) { Artists.Add(artist); } } IsLoading = false; } catch (Exception e) { Console.WriteLine("Error Populate Artists"); Console.WriteLine(e.Message); } }
/// <summary> /// Gets artists /// </summary> private void GetArtists() { User currentUser = Container.Resolve <User>("CurrentUser"); if (currentUser != null) { /* * ArtistsServiceClient serviceClient = Container.Resolve<ArtistsServiceClient>(); * serviceClient.GetArtistsForUser(currentUser.ID, * (artists) => * {*/ // clear existing results Artists.Clear(); // populate new results //artists.ForEach(artist => Artists.Add(artist)); Artists.Add(new Artist() { Name = "October Tide" }); Artists.Add(new Artist() { Name = "The Devin Townsend Project" }); Artists.Add(new Artist() { Name = "Astomatous" }); Artists.Add(new Artist() { Name = "Carnifex" }); Artists.Add(new Artist() { Name = "Machine Head" }); Artists.Add(new Artist() { Name = "The Atlas Moth" }); Artists.Add(new Artist() { Name = "Norma Jean" }); Artists.Add(new Artist() { Name = "All Shall Perish" }); Artists.Add(new Artist() { Name = "All Else Failed" }); Artists.Add(new Artist() { Name = "All That Remains" }); Artists.Add(new Artist() { Name = "All Pigs Must Die" }); /*}); */ } }
private void OnSongUpdated(int id) { Artists.Clear(); LoadArtists(); }
public void RemoveSongs() { Artists.Clear(); }
public void Dispose() { Artists.Clear(); Albums.Clear(); }
public async Task SearchAsync(string term) { if (string.IsNullOrEmpty(term)) { return; } try { if (Tracks != null) { Tracks.Clear(); _tracksResponse = null; } if (Artists != null) { Artists.Clear(); _artistsResponse = null; } if (Albums != null) { Albums.Clear(); _albumsResponse = null; } if (LastTracks != null) { LastTracks.Clear(); _lastTrackResponse = null; } var tasks = new List <Task> { Task.Run( async() => { _tracksResponse = await _spotify.SearchTracksAsync(term); if (_tracksResponse == null) { return; } await DispatcherHelper.RunAsync( () => { Tracks = CreateIncrementalCollection( () => _tracksResponse, tracks => _tracksResponse = tracks, async i => await _spotify.SearchTracksAsync(term, offset: i)); foreach (var lastTrack in _tracksResponse.Items) { Tracks.Add(lastTrack); } }); }), Task.Run( async() => { _albumsResponse = await _spotify.SearchAlbumsAsync(term); if (_albumsResponse == null) { return; } await DispatcherHelper.RunAsync( () => { Albums = CreateIncrementalCollection( () => _albumsResponse, albums => _albumsResponse = albums, async i => await _spotify.SearchAlbumsAsync(term, offset: i)); foreach (var lastAlbum in _albumsResponse.Items) { Albums.Add(lastAlbum); } }); }), Task.Run( async() => { _artistsResponse = await _spotify.SearchArtistsAsync(term); if (_artistsResponse == null) { return; } DispatcherHelper.RunAsync( () => { Artists = CreateIncrementalCollection( () => _artistsResponse, artists => _artistsResponse = artists, async i => await _spotify.SearchArtistsAsync(term, offset: i)); foreach (var lastArtist in _artistsResponse.Items) { Artists.Add(lastArtist); } }); }), Task.Run( async() => { try { _lastTrackResponse = await _service.SearchTracksAsync(term); } catch { // fail silently } if (_lastTrackResponse == null) { return; } await DispatcherHelper.RunAsync( () => { LastTracks = CreateLastIncrementalCollection( () => _lastTrackResponse, artists => _lastTrackResponse = artists, async i => await _service.SearchTracksAsync(term, i)); foreach (var lastTrack in _lastTrackResponse.Content) { LastTracks.Add(lastTrack); } }); }) }; await Task.WhenAll(tasks); } catch { CurtainPrompt.ShowError("AppNetworkIssue".FromLanguageResource()); } }
private async void SearchFilterChangeCommandExecute() { Artists.Clear(); this._morePage = true; await RefreshAsync(); }
public void InitialiseParts() { Albums.Clear(); Artists.Clear(); LoadAlbumAndArtists(); }