private void TabSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (Tabs.SelectedIndex != prevTabIndex)
{
switch (Tabs.SelectedIndex)
{
case 0:
if (trackPackage != CurrentSearchPackage)
{
TrackQuery.FindTracks(CurrentSearchPackage, Dispatcher);
trackPackage = CurrentSearchPackage;
}
EnumerationsContainer.LibraryUi = LibraryUiMode.Songs;
//Dispatcher.BeginInvoke(new Action(() => Scrolls(tracklist)));
break;
case 1:
if (artPackage != CurrentSearchPackage)
{
ArtistQuery.FindArtists(CurrentSearchPackage, Dispatcher);
artPackage = CurrentSearchPackage;
artistList.RefreshUI();
}
EnumerationsContainer.LibraryUi = LibraryUiMode.Artist;
break;
case 2:
if (albPackage != CurrentSearchPackage)
{
AlbumQuery.FindAlbums(CurrentSearchPackage, Dispatcher);
albPackage = CurrentSearchPackage;
albumLst.RefreshUI();
}
EnumerationsContainer.LibraryUi = LibraryUiMode.Album;
break;
case 3:
if (genPackage != CurrentSearchPackage)
{
GenreQuery.FindGenres(CurrentSearchPackage, Dispatcher);
albPackage = CurrentSearchPackage;
genreLst.RefreshUI();
}
EnumerationsContainer.LibraryUi = LibraryUiMode.Genre;
break;
}
RefreshPlugs();
prevTabIndex = Tabs.SelectedIndex;
}
}
public void GetArtistAlbums()
{
var query = new ArtistQuery(_runner);
var result = query.GetByAlbums(2);
Assert.NotNull(result);
Assert.Equal(result.Name, "Accept");
Assert.Equal(result.Albums.Count(), 2);
Assert.NotEmpty(result.Albums);
Assert.Equal(result.Albums.First().Title, "Balls to the Wall");
}
void dpt_Tick(object sender, System.EventArgs e)
{
ticks++;
if (incremented | Player.Instance.NetStreamingConfigsLoaded)
{
return;
}
if (Player.Instance.Wave != null && ticks > Player.Instance.Wave.Duration / 2
| ticks > 4000)
{
incremented = true;
EventHandler handler = IncrementListens;
if (handler != null)
{
handler(this, EventArgs.Empty);
}
//track update
Track existingTrack = TrackQuery.GetTrack(CoreMain.CurrentTrack.Path);
if (existingTrack != null)
{
existingTrack.Listens++;
TrackQuery.SaveTrack(existingTrack);
}
//artistUpdate
ArtistViewModel existingArtist = ArtistQuery.GetArtistViewModel(CoreMain.CurrentTrack.Artist);
if (existingArtist != null)
{
existingArtist.Listens++;
existingArtist.SaveArtist();
}
//albumUpdate
AlbumViewModel existingAlbum = AlbumQuery.GetAlbumViewModel(CoreMain.CurrentTrack.Album);
if (existingAlbum != null)
{
existingAlbum.Listens++;
existingAlbum.SaveAlbum();
}
//a;bumUpdate
ViewModels.GenreViewModel existingGenre = GenreQuery.GetGenreViewModel(CoreMain.CurrentTrack.Genre);
if (existingGenre != null)
{
existingGenre.Listens++;
existingGenre.SaveGenre();
}
//scrobble
LastFm.ScrobbleTrack(LastFm.CurrentTrack);
}
}
public void LoadArtist(string artistName)
{
ArtistViewModel art = ArtistQuery.GetArtistViewModel(artistName);
if (art == null)
{
return;
}
Artist = art.Name;
artist.Text = art.Name;
duration.Text = " " + TimeSpan.FromSeconds(art.Duration);
var tracks = TrackQuery.GetTracksFromArtist(art.Name);
tracklist.ItemsSource = tracks;
albums.Text = " " + tracks.GroupBy(x => x.Album).Count() + " albums";
rateCtl.Path = art.Name;
rateCtl.Rate = art.Rate;
selArtist.FadeOut();
}
public ArtistsController(ArtistQuery artistQuery, ArtistUpdateService updateService)
{
_artistQuery = artistQuery;
_updateService = updateService;
}
public static TrackViewModel AddFile(string file)
{
try
{
var d = new TrackViewModel();
//Build tags
TrackViewModel track = TaglibCore.BuildTrack(file);
try
{
//Save Track
track.SaveTrack();
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
//==============
//Artists
//==============
//Do the operations for artists
ArtistViewModel art = ArtistQuery.GetArtistViewModel(track.Artist);
art = art ?? new ArtistViewModel();
art.Name = track.Artist;
art.Duration += track.Duration;
art.SongCount++;
art.SaveArtist();
//==============
//Genre
//==============
ViewModels.GenreViewModel gens = GenreQuery.GetGenreViewModel(track.Genre);
gens = gens ?? new ViewModels.GenreViewModel();
gens.Name = track.Genre;
gens.Duration += track.Duration;
gens.SongCount++;
gens.SaveGenre();
//==============
//Albums
//==============
AlbumViewModel albs = AlbumQuery.GetAlbumViewModel(track.Album);
albs = albs ?? new AlbumViewModel();
albs.Name = track.Album;
albs.Artist = track.Artist;
albs.Duration += track.Duration;
albs.SongCount++;
albs.ID = track.Album;
albs.SaveAlbum();
if (track.Album.ToLower() != "unknown album")
{
//Global.SaveAlbumArt(album + " - " + Artists, tgl.getArtStream());
//opt.SaveThumb("My Library\\AlbumArt\\" + album + " - " + Artists + ".jpg.thumb");
}
Tracks.Add(track);
Artists.Add(art);
Albums.Add(albs);
Genres.Add(gens);
App.Current.Dispatcher.Invoke(new Action(() =>
{
var mw = App.Current.MainWindow as MainWindow;
if (mw != null)
{
if (mw.hLibrary.grdDD.Visibility == Visibility.Visible)
{
mw.hLibrary.grdDD.FadeOut();
}
}
if (SOFilter.ValidGenre(Results.TrackSearch, gens))
{
Results.Genres.Add(gens);
}
if (SOFilter.ValidArtist(Results.TrackSearch, art))
{
Results.Artists.Add(art);
}
if (SOFilter.ValidAlbum(Results.TrackSearch, albs))
{
Results.Albums.Add(albs);
}
if (SOFilter.ValidTrack(Results.TrackSearch, track))
{
Results.Tracks.Add(track);
}
}));
return(track);
}
catch
{
}
return(null);
}
/// <summary>
/// Workers load
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void worker_load(object sender, DoWorkEventArgs e)
{
//Load lists
//InitializeLists();
if (Results.Tracks == null)
{
Results.Tracks = new ObservableCollection <TrackViewModel>();
}
if (Results.Artists == null)
{
Results.Artists = new ObservableCollection <ArtistViewModel>();
}
if (Results.Albums == null)
{
Results.Albums = new ObservableCollection <AlbumViewModel>();
}
if (Results.Genres == null)
{
Results.Genres = new ObservableCollection <ViewModels.GenreViewModel>();
}
DB_InUse = true;
try
{
NotifyPropertyChanged("Initialized");
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (ListenToChanges != null)
{
ListenToChanges(new TrackViewModel()
{
Title = "Searching"
}, SearchGuid);
}
}));
files =
Search(@path, "*.*")
.Where(
s =>
s.ToLower().EndsWith(".mp3") || s.ToLower().EndsWith(".wma") ||
s.ToLower().EndsWith(".flac") || s.ToLower().EndsWith(".ogg") ||
s.ToLower().EndsWith(".wav") || s.ToLower().EndsWith(".mp2") ||
s.ToLower().EndsWith(".mp1") || s.ToLower().EndsWith(".m4a"));
;
max = files.Count();
NotifyPropertyChanged("New Count");
}
catch
{
}
//NotifyPropertyChanged("New Count");
//tag data holding variables
int mval = 0;
if (files == null)
// if there is nothin in files, return
{
//Settings.Default.LibSearchPath = "";
//Settings.Default.LibSearchCompleted = true;
Settings.Default.Save();
return;
}
var artists = new Dictionary <string, ArtistViewModel>();
var albums = new Dictionary <string, AlbumViewModel>();
var genres = new Dictionary <string, ViewModels.GenreViewModel>();
Parallel.ForEach(files, new ParallelOptions {
MaxDegreeOfParallelism = 1
}, file =>
{
if (GlobalSearchCancel)
{
return;
}
try
{
var d = new TrackViewModel();
//Build tags
TrackViewModel track = TaglibCore.BuildTrack(file);
try
{
//Save Track
if (!string.IsNullOrEmpty(track.Title) && track.SaveTrack() == "success")
{
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidTrack(Results.TrackSearch, track))
{
if (!Results.Tracks.Contains(track))
{
Results.Tracks.Add(track);
}
}
}));
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
//==============
//Artists
//==============
//Add the artist to dictionary from DB if the dictionary doesnt have already
if (!artists.ContainsKey(track.Artist))
{
ArtistViewModel arts = ArtistQuery.GetArtistViewModel(track.Artist);
if (arts != null)
{
artists.Add(track.Artist, arts);
}
else
{
artists.Add(track.Artist, new ArtistViewModel());
}
}
//Do the operations for artists
ArtistViewModel art = artists[track.Artist];
art.Name = track.Artist;
art.Duration += track.Duration;
art.SongCount++;
art.SaveArtist();
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidArtist(Results.TrackSearch, art))
{
ArtistViewModel exar;
try
{
exar = Results.Artists.Single(c => c.Name == art.Name);
}
catch (Exception exception)
{
exar = null;
}
if (exar == null)
{
Results.Artists.Add(art);
}
else
{
exar.Listens = art.Listens;
exar.Duration = art.Duration;
exar.SongCount = art.SongCount;
exar.Name = art.Name;
}
}
}));
//==============
//Genre
//==============
//Add the album to dictionary from DB if the dictionary doesnt have already
if (!genres.ContainsKey(track.Genre))
{
ViewModels.GenreViewModel al = GenreQuery.GetGenreViewModel(track.Genre);
if (al != null)
{
genres.Add(track.Genre, al);
}
else
{
genres.Add(track.Genre, new ViewModels.GenreViewModel());
}
}
ViewModels.GenreViewModel gens = genres[track.Genre];
gens.Name = track.Genre;
gens.Duration += track.Duration;
gens.SongCount++;
gens.SaveGenre();
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidGenre(Results.TrackSearch, gens))
{
ViewModels.GenreViewModel exar;
try
{
exar = Results.Genres.Single(c => c.Name == gens.Name);
}
catch (Exception exception)
{
exar = null;
}
if (exar == null)
{
Results.Genres.Add(gens);
}
else
{
exar.Listens = art.Listens;
exar.Duration = art.Duration;
exar.SongCount = art.SongCount;
exar.Name = art.Name;
}
}
}));
//==============
//Albums
//==============
//Add the genre to dictionary from DB if the dictionary doesnt have already
if (!albums.ContainsKey(track.Album))
{
AlbumViewModel al = AlbumQuery.GetAlbumViewModel(track.Album);
if (al != null)
{
albums.Add(track.Album, al);
}
else
{
albums.Add(track.Album, new AlbumViewModel());
}
}
AlbumViewModel albs = albums[track.Album];
albs.Name = track.Album;
albs.Artist = track.Artist;
albs.Duration += track.Duration;
albs.SongCount++;
albs.ID = track.Album;
albs.SaveAlbum();
App.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (SOFilter.ValidAlbum(Results.TrackSearch, albs))
{
AlbumViewModel exar;
try
{
exar = Results.Albums.Single(c => c.ID == albs.ID);
}
catch (Exception exception)
{
exar = null;
}
if (exar == null)
{
Results.Albums.Add(albs);
}
else
{
exar.Listens = art.Listens;
exar.Duration = art.Duration;
exar.SongCount = art.SongCount;
exar.Name = art.Name;
}
}
}));
if (track.Album.ToLower() != "unknown album")
{
//Global.SaveAlbumArt(album + " - " + Artists, tgl.getArtStream());
//opt.SaveThumb("My Library\\AlbumArt\\" + album + " - " + Artists + ".jpg.thumb");
}
if (!Tracks.Any(c => c.Path == track.Path))
{
Tracks.Add(track);
}
if (!Artists.Any(c => c.Name == art.Name))
{
Artists.Add(art);
}
if (!Albums.Any(c => c.Name == albs.Name))
{
Albums.Add(albs);
}
if (!Genres.Any(c => c.Name == gens.Name))
{
Genres.Add(gens);
}
//Playlist callbacks
triggerCallback(track, SearchGuid);
ListenToChanges(track, SearchGuid);
}
catch
{
}
mval += 1;
cworker.ReportProgress(mval);
});
}
public ArtistController(ArtistQuery query, ArtistCommand command)
{
_query = query;
_command = command;
}
