private void HandleAlbumModelPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case AlbumModel.Properties.AlbumArt:
_albumArt = null;
NotifyPropertyChanged(Properties.AlbumArtSource);
NotifyPropertyChanged(Properties.HasAlbumArt);
UpdateAlbumArt();
break;
case AlbumModel.Properties.ArtistId:
NotifyPropertyChanged(Properties.Artist);
NotifyPropertyChanged(Properties.ArtistName);
break;
case AlbumModel.Properties.AlbumId:
DebugHelper.Alert(new CallerInfo(), "AlbumId Probably Shouldn't Change...");
NotifyPropertyChanged(Properties.AlbumId);
break;
case AlbumModel.Properties.Name:
_sortName = null;
NotifyPropertyChanged(Properties.SortName);
NotifyPropertyChanged(Properties.Name);
break;
}
}
public static IMixEvaluator RangeMixEntryModelToMixEvaluator(MixType mixType, string input)
{
PropertyInfo info = null;
switch (mixType & MixType.SUBTYPE_MASK)
{
case MixType.LASTPLAYED_SUBTYPE:
info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.LastPlayed);
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected RANGE_TYPE MixType {0}", mixType);
break;
}
RangeEvalType rangeEvalType = RangeEvalType.Unknown;
switch (mixType & MixType.VARIANT_MASK)
{
case MixType.RANGE_DAYS_VARIANT:
rangeEvalType = RangeEvalType.Days;
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected RANGE_TYPE VARIANT_MASK MixType {0}", mixType);
break;
}
if (info != null)
{
return(new RangeMixEvaluator(info, int.Parse(input), rangeEvalType, mixType));
}
return(null);
}
internal void SaveState(Dictionary <string, object> pageState)
{
if (Root.ItemsPanelRoot == null)
{
return;
}
ItemsStackPanel stackPanel = Root.ItemsPanelRoot as ItemsStackPanel;
if (stackPanel != null)
{
pageState.Add(LAST_INDEX_KEY, stackPanel.LastVisibleIndex);
}
else
{
ItemsWrapGrid wrapGrid = Root.ItemsPanelRoot as ItemsWrapGrid;
if (wrapGrid != null)
{
pageState.Add(LAST_INDEX_KEY, wrapGrid.LastVisibleIndex);
}
else
{
DebugHelper.Alert(new CallerInfo(), "Unexpected root type: {0}", Root.ItemsPanelRoot.GetType());
}
}
}
public void RemoveEntry(int entryId)
{
PlaylistEntryModel songToRemove = null;
if (!IndexLookupMap.TryGetValue(entryId, out songToRemove))
{
DebugHelper.Alert(new CallerInfo(), "Tried to remove play queue entry {0} but its not in our lookup", entryId);
return;
}
PlaylistEntryModel previousModel = null;
if (IndexLookupMap.TryGetValue(songToRemove.PrevId, out previousModel))
{
previousModel.NextId = songToRemove.NextId;
}
PlaylistEntryModel nextModel = null;
if (IndexLookupMap.TryGetValue(songToRemove.NextId, out nextModel))
{
nextModel.PrevId = songToRemove.PrevId;
}
SongIds.Remove(songToRemove.SongId);
Songs.Remove(songToRemove);
IndexLookupMap.Remove(songToRemove.RowId);
DatabaseManager.Current.DeletePlaylistEntry(songToRemove.RowId);
}
public bool Eval(SongViewModel song)
{
switch (EvalType)
{
case MemberEvalType.Playlist:
PlaylistViewModel playlist = LibraryViewModel.Current.LookupPlaylistById(Target);
if (playlist == null)
{
return(false);
}
return(playlist.ContainsSong(song));
case MemberEvalType.Mix:
MixViewModel mix = LibraryViewModel.Current.LookupMixById(Target);
if (mix == null)
{
return(false);
}
return(mix.ContainsSong(song));
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MemberEvalType: {0}", EvalType);
return(false);
}
}
public static IMixEvaluator NestedMixEntryModelToMixEvaluator(MixType mixType, List <IMixEvaluator> mixes)
{
NestedEvalType nestedEvalType = NestedEvalType.Unknown;
switch (mixType)
{
case MixType.And:
nestedEvalType = NestedEvalType.All;
break;
case MixType.Or:
nestedEvalType = NestedEvalType.Any;
break;
case MixType.Not:
nestedEvalType = NestedEvalType.None;
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected NESTED_TYPE MixType {0}", mixType);
break;
}
return(new NestedMixEvaluator(mixes, nestedEvalType, mixType));
}
private Type NavigationLocationToPageType(NavigationLocation location)
{
switch (location)
{
case NavigationLocation.AlbumList:
return(typeof(AlbumList));
case NavigationLocation.AlbumPage:
return(typeof(AlbumPage));
case NavigationLocation.ArtistList:
return(typeof(ArtistList));
case NavigationLocation.ArtistPage:
return(typeof(ArtistPage));
case NavigationLocation.Home:
return(typeof(HomePage));
case NavigationLocation.ManageLibrary:
return(typeof(ManageLibrary));
case NavigationLocation.MixList:
return(typeof(MixList));
case NavigationLocation.MixPage:
return(typeof(MixPage));
case NavigationLocation.PlaylistList:
return(typeof(PlaylistList));
case NavigationLocation.PlaylistPage:
return(typeof(PlaylistPage));
case NavigationLocation.SearchPage:
return(typeof(SearchPage));
case NavigationLocation.SettingsPage:
return(typeof(Settings));
case NavigationLocation.SongList:
return(typeof(SongList));
case NavigationLocation.Queue:
return(typeof(Queue));
case NavigationLocation.NowPlaying:
return(typeof(NowPlaying));
case NavigationLocation.NewHome:
return(typeof(NewHomePage));
case NavigationLocation.Library:
return(typeof(Library));
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected NavigationLocation {0}", location);
return(typeof(HomePage));
}
}
public bool Eval(SongViewModel song)
{
T targetValue = DebugHelper.CastAndAssert <T>(TargetProperty.GetValue(song));
switch (EvalType)
{
case NumericEvalType.StrictLess:
return(targetValue.CompareTo(Target) < 0);
case NumericEvalType.Less:
return(targetValue.CompareTo(Target) <= 0);
case NumericEvalType.Equal:
return(targetValue.CompareTo(Target) == 0);
case NumericEvalType.More:
return(targetValue.CompareTo(Target) >= 0);
case NumericEvalType.StrictMore:
return(targetValue.CompareTo(Target) > 0);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected NumericEvalType: {0}", EvalType);
return(false);
}
}
private void HandleMixLimitTextBoxGotFocus(object sender, RoutedEventArgs e)
{
Transform stackPanelRestore = DebugHelper.CastAndAssert <Transform>(((TextBox)sender).TransformToVisual(rootGrid));
double shift = 0;
if (stackPanelRestore is MatrixTransform)
{
shift = (stackPanelRestore as MatrixTransform).Matrix.OffsetY;
}
else if (stackPanelRestore is TranslateTransform)
{
shift = (stackPanelRestore as TranslateTransform).Y;
}
else
{
DebugHelper.Alert(new CallerInfo(), "Unexpected transform type {0}", stackPanelRestore.GetType());
}
TranslateTransform shiftDown = new TranslateTransform();
shiftDown.Y = 90 - shift;
TransformGroup group = new TransformGroup();
group.Children.Add(shiftDown);
rootGrid.RenderTransform = group;
RootScrollViewer.VerticalScrollMode = ScrollMode.Disabled;
}
public static string BGMessageIdToMessageString(PlayQueueConstantBGMessageId messageId)
{
switch (messageId)
{
case PlayQueueConstantBGMessageId.BackgroundEnded:
return(BackgroundEnded);
case PlayQueueConstantBGMessageId.BackgroundStarted:
return(BackgroundStarted);
case PlayQueueConstantBGMessageId.SeekComplete:
return(SeekComplete);
case PlayQueueConstantBGMessageId.TrackChanged:
return(TrackChanged);
case PlayQueueConstantBGMessageId.TrackPlayed:
return(TrackPlayed);
case PlayQueueConstantBGMessageId.PlayQueueFinished:
return(PlayQueueFinished);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected PlayQueueConstantBGMessageId {0} encountered", messageId.ToString());
return(Unknown);
}
}
public static IMixEvaluator StringMixEntryModelToMixEvaluator(MixType type, string input)
{
PropertyInfo info = null;
switch (type & MixType.SUBTYPE_MASK)
{
case MixType.ALBUM_SUBTYPE:
info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.AlbumSortName);
break;
case MixType.ALBUMARTIST_SUBTYPE:
info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.AlbumArtistSortName);
break;
case MixType.ARTIST_SUBTYPE:
info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.AlbumSortName);
break;
case MixType.TRACK_SUBTYPE:
info = typeof(SongViewModel).GetRuntimeProperty(SongViewModel.Properties.Name);
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected ALBUM_TYPE MixType {0}", type);
break;
}
StringEvalType stringEvalType = StringEvalType.Unknown;
switch (type & MixType.VARIANT_MASK)
{
case MixType.STRING_CONTAINS_VARIANT:
stringEvalType = StringEvalType.SubString;
break;
case MixType.STRING_ENDSWITH_VARIANT:
stringEvalType = StringEvalType.EndsWith;
break;
case MixType.STRING_EQUAL_VARIANT:
stringEvalType = StringEvalType.Equal;
break;
case MixType.STRING_STARTSWITH_VARIANT:
stringEvalType = StringEvalType.StartsWith;
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected ALBUM_TYPE VARIANT_MASK MixType {0}", type);
break;
}
if (info != null)
{
return(new StringMixEvaluator(info, input, stringEvalType, type));
}
return(new NoneMixEvaluator());
}
void HandleSongModelPropertyChanged(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case SongModel.Properties.AlbumId:
NotifyPropertyChanged(Properties.Album);
NotifyPropertyChanged(Properties.AlbumName);
NotifyPropertyChanged(Properties.AlbumArtistName);
NotifyPropertyChanged(Properties.AlbumSortName);
NotifyPropertyChanged(Properties.AlbumArtistSortName);
break;
case SongModel.Properties.ArtistId:
NotifyPropertyChanged(Properties.Artist);
NotifyPropertyChanged(Properties.ArtistName);
NotifyPropertyChanged(Properties.ArtistSortName);
break;
case SongModel.Properties.Duration:
Album.ResetLength();
NotifyPropertyChanged(Properties.Duration);
NotifyPropertyChanged(Properties.DurationText);
NotifyPropertyChanged(Properties.DurationSeconds);
break;
case SongModel.Properties.SongId:
DebugHelper.Alert(new CallerInfo(), "SongId Shouldn't Change");
NotifyPropertyChanged(Properties.SongId);
break;
case SongModel.Properties.Name:
_sortName = null;
NotifyPropertyChanged(Properties.SortName);
NotifyPropertyChanged(Properties.Name);
break;
case SongModel.Properties.PlayCount:
NotifyPropertyChanged(Properties.PlayCount);
NotifyPropertyChanged(Properties.ExtraInfoString);
break;
case SongModel.Properties.Rating:
NotifyPropertyChanged(Properties.Rating);
break;
case SongModel.Properties.TrackNumber:
NotifyPropertyChanged(Properties.TrackNumber);
break;
case SongModel.Properties.LastPlayed:
_lastPlayed = null;
NotifyPropertyChanged(Properties.LastPlayed);
NotifyPropertyChanged(Properties.ExtraInfoString);
break;
}
LibraryViewModel.Current.AlertSongChanged(this, e.PropertyName);
}
public static MixType RangeEvalTypeToMixTypeVariant(RangeEvalType evalType)
{
switch (evalType)
{
case RangeEvalType.Days:
return(MixType.RANGE_DAYS_VARIANT);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected eval type");
return(MixType.None);
}
}
internal bool AddSong(StorageProviderSong song, bool resetSongData)
{
SongModel songFromSource = LibraryModel.Current.GetSongFromSource(StorageProviderSourceToSongOriginSource(song.Origin), song.Source);
if (songFromSource != null)
{
if (resetSongData)
{
SongViewModel songViewModel = LookupSong(songFromSource);
songViewModel.Name = song.Name;
songViewModel.ArtistName = song.Artist;
string newAlbumName = song.Album;
string newAlbumAristName = song.AlbumArtist;
if (newAlbumName != songViewModel.Album.Name || newAlbumAristName != songViewModel.Album.ArtistName)
{
ArtistViewModel albumArtistViewModel = LibraryViewModel.Current.LookupArtistByName(newAlbumAristName);
AlbumViewModel newAlbumViewModel = LibraryViewModel.Current.LookupAlbumByName(newAlbumName, albumArtistViewModel.ArtistId);
songViewModel.UpdateAlbum(newAlbumViewModel);
}
songViewModel.TrackNumber = song.TrackNumber;
}
return(false);
}
SongModel newSongModel = LibraryModel.Current.AddNewSong(
song.Artist,
song.Album,
song.AlbumArtist,
song.Name,
song.Source,
StorageProviderSourceToSongOriginSource(song.Origin),
song.Duration.Ticks,
song.Rating,
song.TrackNumber
);
if (LookupSong(newSongModel) == null)
{
DebugHelper.Alert(new CallerInfo(), "Failed to add song");
return(false);
}
return(true);
}
private SongOriginSource StorageProviderSourceToSongOriginSource(StorageProviderSource sps)
{
switch (sps)
{
case StorageProviderSource.Device:
return(SongOriginSource.Device);
case StorageProviderSource.OneDrive:
return(SongOriginSource.OneDrive);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected StorageProviderSource {0}", sps);
return(SongOriginSource.Unknown);
}
}
private void HandleArtistModelPropertyChanged(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case ArtistModel.Properties.ArtistId:
DebugHelper.Alert(new CallerInfo(), "ArtistId Probably Shouldn't Change...");
NotifyPropertyChanged(Properties.ArtistId);
break;
case ArtistModel.Properties.Name:
_sortName = null;
NotifyPropertyChanged(Properties.SortName);
NotifyPropertyChanged(Properties.Name);
break;
}
}
public bool Eval(SongViewModel song)
{
DateTime targetValue = DebugHelper.CastAndAssert <DateTime>(TargetProperty.GetValue(song));
switch (EvalType)
{
case RangeEvalType.Days:
DateTime target = DateTime.Now - TimeSpan.FromDays(Target);
return(target < targetValue);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MemberEvalType: {0}", EvalType);
return(false);
}
}
private void Seek(double percentage)
{
if (BackgroundMediaPlayer.Current != null)
{
DebugHelper.Assert(new CallerInfo(), 0 <= percentage && percentage <= 1, "Seek to out of ranged position");
long newTicks = (long)(percentage * BackgroundMediaPlayer.Current.NaturalDuration.Ticks);
BackgroundMediaPlayer.Current.Position = TimeSpan.FromTicks(newTicks);
}
else
{
PlayQueueManager.Current.SendMessageToForeground(PlayQueueConstantBGMessageId.SeekComplete);
DebugHelper.Alert(new CallerInfo(), "Seeking attempt with null BMP");
}
}
private void UpdateMemberState(MixType type)
{
switch (type & MixType.SUBTYPE_MASK)
{
case MixType.PLAYLISTMEMBER_SUBTYPE:
VisualStateManager.GoToState(this, "MemberPlaylistSelected", false);
break;
case MixType.MIXMEMBER_SUBTYPE:
VisualStateManager.GoToState(this, "MemberMixSelected", false);
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected numeric mix type: {0}", type);
VisualStateManager.GoToState(this, "MemberUnknownSelected", false);
return;
}
}
private string ConvertNumericValueToString(MixType type)
{
switch (type & MixType.SUBTYPE_MASK)
{
case MixType.LENGTH_SUBTYPE:
return(NumericValue.Text);
case MixType.RATING_SUBTYPE:
return(NumericStarRater.Rating.ToString());
case MixType.PLAYCOUNT_SUBTYPE:
return(NumericValue.Text);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected numeric mix type: {0}", type);
return("0");
}
}
private void UpdateFullTime()
{
if (CurrentEntry == null)
{
FullTime = TimeSpan.Zero;
}
else
{
SongTable song = DatabaseManager.Current.LookupSongById(CurrentEntry.SongId);
if (song == null)
{
DebugHelper.Alert(new CallerInfo(), "SongId {0} got from a playqueue row but couldn't find it in database!!", CurrentEntry.SongId);
FullTime = TimeSpan.Zero;
}
else
{
FullTime = TimeSpan.FromTicks(song.Duration);
}
}
}
public static IMixEvaluator MemberMixEntryModelToMixEvaluator(MixType mixType, string input)
{
MemberEvalType memberEvalType = MemberEvalType.Unknown;
switch (mixType & MixType.SUBTYPE_MASK)
{
case MixType.MIXMEMBER_SUBTYPE:
memberEvalType = MemberEvalType.Mix;
break;
case MixType.PLAYLISTMEMBER_SUBTYPE:
memberEvalType = MemberEvalType.Playlist;
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MEMBER_TYPE MixType {0}", mixType);
break;
}
return(new MemberMixEvaluator(int.Parse(input), memberEvalType, mixType));
}
public static MixType StringEvalTypeToMixTypeVariant(StringEvalType evalType)
{
switch (evalType)
{
case StringEvalType.EndsWith:
return(MixType.STRING_ENDSWITH_VARIANT);
case StringEvalType.StartsWith:
return(MixType.STRING_STARTSWITH_VARIANT);
case StringEvalType.SubString:
return(MixType.STRING_CONTAINS_VARIANT);
case StringEvalType.Equal:
return(MixType.STRING_EQUAL_VARIANT);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected eval type");
return(MixType.None);
}
}
private void UpdateView()
{
switch (this.ViewType)
{
case SongListItemView.SongList:
VisualStateManager.GoToState(this, "ViewTypeSongList", false);
break;
case SongListItemView.AlbumPage:
VisualStateManager.GoToState(this, "ViewTypeAlbumPage", false);
break;
case SongListItemView.ArtistPage:
VisualStateManager.GoToState(this, "ViewTypeArtistPage", false);
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unknown SongListItemView {0}", this.ViewType);
break;
}
}
public bool Eval(SongViewModel song)
{
switch (EvalType)
{
case NestedEvalType.Any:
foreach (IMixEvaluator nestedMix in Mixes)
{
if (nestedMix.Eval(song))
{
return(true);
}
}
return(false);
case NestedEvalType.All:
foreach (IMixEvaluator nestedMix in Mixes)
{
if (!nestedMix.Eval(song))
{
return(false);
}
}
return(true);
case NestedEvalType.None:
foreach (IMixEvaluator nestedMix in Mixes)
{
if (nestedMix.Eval(song))
{
return(false);
}
}
return(true);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected NestedEvalType: {0}", EvalType);
return(false);
}
}
private void UpdateNumericState(MixType type)
{
switch (type & MixType.SUBTYPE_MASK)
{
case MixType.LENGTH_SUBTYPE:
VisualStateManager.GoToState(this, "NumericDurationSelected", false);
break;
case MixType.RATING_SUBTYPE:
VisualStateManager.GoToState(this, "NumericRatingSelected", false);
break;
case MixType.PLAYCOUNT_SUBTYPE:
VisualStateManager.GoToState(this, "NumericPlayCountSelected", false);
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected numeric mix type: {0}", type);
VisualStateManager.GoToState(this, "NumericUnknownSelected", false);
return;
}
}
private void UpdateNumericStartingValue(MixType type, IComparable target)
{
switch (type & MixType.SUBTYPE_MASK)
{
case MixType.LENGTH_SUBTYPE:
NumericValue.Text = target.ToString();
break;
case MixType.RATING_SUBTYPE:
NumericStarRater.Rating = DebugHelper.CastAndAssert <uint>(target);
break;
case MixType.PLAYCOUNT_SUBTYPE:
NumericValue.Text = target.ToString();
break;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected numeric mix type: {0}", type);
NumericValue.Text = "0";
return;
}
}
public void RemoveEntry(int entryId)
{
if (entryId == CurrentPlaybackQueueEntryId)
{
Stop();
CurrentPlaybackQueueEntryId = 0;
}
PlayQueueEntryModel songToRemove = null;
if (!LookupMap.TryGetValue(entryId, out songToRemove))
{
DebugHelper.Alert(new CallerInfo(), "Tried to remove play queue entry {0} but its not in our lookup", entryId);
return;
}
PlayQueueEntryModel previousModel = null;
if (LookupMap.TryGetValue(songToRemove.PrevId, out previousModel))
{
previousModel.NextId = songToRemove.NextId;
}
PlayQueueEntryModel nextModel = null;
if (LookupMap.TryGetValue(songToRemove.NextId, out nextModel))
{
nextModel.PrevId = songToRemove.PrevId;
}
PlaybackQueue.Remove(songToRemove);
LookupMap.Remove(songToRemove.RowId);
DatabaseManager.Current.DeletePlayQueueEntry(songToRemove.RowId);
NotifyPropertyChanged(Properties.NextTrack);
NotifyPropertyChanged(Properties.PrevTrack);
}
public bool Eval(SongViewModel song)
{
string targetValue = DebugHelper.CastAndAssert <string>(TargetProperty.GetValue(song));
switch (EvalType)
{
case StringEvalType.Equal:
return(targetValue == Target);
case StringEvalType.SubString:
return(targetValue.Contains(Target));
case StringEvalType.StartsWith:
return(targetValue.StartsWith(Target));
case StringEvalType.EndsWith:
return(targetValue.EndsWith(Target));
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected StringEvalType: {0}", EvalType);
return(false);
}
}
internal static string FGMessageIdToMessageString(PlayQueueConstantFGMessageId messageId)
{
switch (messageId)
{
case PlayQueueConstantFGMessageId.AppResumed:
return(AppResumed);
case PlayQueueConstantFGMessageId.AppSuspended:
return(AppSuspended);
case PlayQueueConstantFGMessageId.LoggingEnabledChanged:
return(LoggingEnabledChanged);
case PlayQueueConstantFGMessageId.PlayPauseTrack:
return(PlayPauseTrack);
case PlayQueueConstantFGMessageId.PossibleChromeChange:
return(PossibleChromeChange);
case PlayQueueConstantFGMessageId.PrevTrack:
return(PrevTrack);
case PlayQueueConstantFGMessageId.ScrubToPercentage:
return(ScrubToPercentage);
case PlayQueueConstantFGMessageId.SkipTrack:
return(SkipTrack);
case PlayQueueConstantFGMessageId.StartPlayback:
return(StartPlayback);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected PlayQueueConstantFGMessageId {0} encountered", messageId.ToString());
return(Unknown);
}
}
