private async Task LoadFolder(StorageFolder folder, DateTime lastSync)
{
if (isCanceled)
{
return;
}
IReadOnlyList <IStorageItem> fileList = await folder.GetItemsAsync();
foreach (IStorageItem storageItem in fileList)
{
if (storageItem.IsOfType(StorageItemTypes.File))
{
StorageFile storageFile = DebugHelper.CastAndAssert <StorageFile>(storageItem);
await LoadFile(storageFile);
}
else if (storageItem.IsOfType(StorageItemTypes.Folder))
{
StorageFolder storageFolder = DebugHelper.CastAndAssert <StorageFolder>(storageItem);
BasicProperties basicProperties = await storageFolder.GetBasicPropertiesAsync();
DateTime candidateTime = basicProperties.DateModified.UtcDateTime;
if (candidateTime > lastSync)
{
await LoadFolder(storageFolder, lastSync);
}
}
}
}
public void Connect()
{
sqlConnection = new SQLiteConnection(DB_PATH);
if (!ApplicationData.Current.LocalSettings.Values.ContainsKey(DB_VERSION_KEY))
{
ApplicationData.Current.LocalSettings.Values.Add(DB_VERSION_KEY, 0);
}
int currentDatabaseVersion = DebugHelper.CastAndAssert <int>(ApplicationData.Current.LocalSettings.Values[DB_VERSION_KEY]);
if (currentDatabaseVersion < 1)
{
sqlConnection.CreateTable <ArtistTable>();
sqlConnection.CreateTable <AlbumTable>();
sqlConnection.CreateTable <SongTable>();
sqlConnection.CreateTable <PlayQueueEntryTable>();
sqlConnection.CreateTable <PlaylistTable>();
sqlConnection.CreateTable <PlaylistEntryTable>();
sqlConnection.CreateTable <HistoryTable>();
sqlConnection.CreateTable <MixTable>();
sqlConnection.CreateTable <MixEntryTable>();
}
if (currentDatabaseVersion < DB_VERSION)
{
ApplicationData.Current.LocalSettings.Values[DB_VERSION_KEY] = DB_VERSION;
}
}
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 async Task LoadFile(StorageFile file)
{
if (isCanceled)
{
return;
}
if (Utilities.IsSupportedFileType(file.FileType))
{
StorageItemContentProperties fileProperties = file.Properties;
MusicProperties musicProperties = await fileProperties.GetMusicPropertiesAsync();
IDictionary <string, object> artistProperties = await fileProperties.RetrievePropertiesAsync(RealMusicProperties);
object artists = null;
artistProperties.TryGetValue("System.Music.Artist", out artists);
string[] artistsAsArray = DebugHelper.CastAndAssert <string[]>(artists);
string artistName = string.Empty;
if (artistsAsArray != null && artistsAsArray.Length > 0)
{
artistName = artistsAsArray[0];
}
if (this.TrackScanned != null)
{
this.TrackScanned(this, new TrackScannedEventArgs(new StorageProviderSong(file.Path, musicProperties, artistName)));
}
}
}
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 object Convert(object value, Type targetType, object parameter, string language)
{
double valueAsDouble = DebugHelper.CastAndAssert <double>(value);
System.Diagnostics.Debug.WriteLine("Input " + valueAsDouble + " output " + ((valueAsDouble) / Sections - Margin));
return((valueAsDouble) / Sections - Margin);
}
async void HandleBackgroundMediaPlayerMessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
case PlayQueueMessageHelper.BackgroundStarted:
BackgroundInitialized.Set();
break;
case PlayQueueMessageHelper.SeekComplete:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
isScrubInProgress = false;
CurrentTime = BackgroundMediaPlayer.Current.Position;
});
break;
case PlayQueueMessageHelper.TrackChanged:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (!isScrubInProgress)
{
CurrentTime = BackgroundMediaPlayer.Current.Position;
}
else
{
CurrentTime = TimeSpan.Zero;
}
FullTime = BackgroundMediaPlayer.Current.NaturalDuration;
CurrentPlaybackQueueEntryId = DebugHelper.CastAndAssert <int>(e.Data[key]);
});
break;
case PlayQueueMessageHelper.TrackPlayed:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
UpdateHistory();
});
break;
case PlayQueueMessageHelper.PlayQueueFinished:
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ResetPlayerToStart();
IsActive = false;
IsPlaying = false;
CurrentTime = TimeSpan.Zero;
});
break;
}
}
}
private void ExecuteNavigate(object parameter)
{
string parameterAsString = DebugHelper.CastAndAssert <string>(parameter);
NavigationLocation target = NavigationLocation.Home;
DebugHelper.Assert(new CallerInfo(), Enum.TryParse <NavigationLocation>(parameterAsString, out target), "Couldn't find location named {0}", parameterAsString);
NavigationManager.Current.Navigate(target);
}
internal void LoadState(Dictionary <string, object> pageState)
{
object lastIndex;
if (pageState != null && pageState.TryGetValue(LAST_INDEX_KEY, out lastIndex))
{
lastFrameInViewIndex = DebugHelper.CastAndAssert <int>(lastIndex);
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
SolidColorBrush valueAsBrush = DebugHelper.CastAndAssert <SolidColorBrush>(value);
if (valueAsBrush == TargetBrush)
{
return(TargetStyle);
}
return(null);
}
protected override Style SelectStyleCore(object item, DependencyObject container)
{
MixViewModel itemAsMixViewModel = DebugHelper.CastAndAssert <MixViewModel>(item);
if (itemAsMixViewModel.IsHidden)
{
return(EmptyStyle);
}
return(null);
}
public static T GetSettingsValue <T>(string key, T defaultValue)
{
if (!ApplicationData.Current.LocalSettings.Values.ContainsKey(key))
{
ApplicationData.Current.LocalSettings.Values.Add(key, defaultValue);
Logger.Current.Log(new CallerInfo(), LogLevel.Warning, "Setting {0} does not exist, defaulting to {1}", key, defaultValue);
}
return(DebugHelper.CastAndAssert <T>(ApplicationData.Current.LocalSettings.Values[key]));
}
private void UpdateTheme()
{
SolidColorBrush brush = DebugHelper.CastAndAssert <SolidColorBrush>(App.Current.Resources["PhoneAccentBrush"]);
Color c = brush.Color;
c.R = (byte)(byte.MaxValue - c.R * 0.2);
c.G = (byte)(byte.MaxValue - c.G * 0.2);
c.B = (byte)(byte.MaxValue - c.B * 0.2);
((SolidColorBrush)App.Current.Resources["PlayerControlBackgroundColor"]).Color = c;
}
protected U GetTableField <U>(string tableProperty)
{
PropertyInfo propertyInfo = typeof(T).GetRuntimeProperty(tableProperty);
if (propertyInfo != null)
{
return(DebugHelper.CastAndAssert <U>(propertyInfo.GetValue(rootTable)));
}
else
{
return(default(U));
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
double valueAsDouble = DebugHelper.CastAndAssert <double>(value);
double LeftBase = 20;
double RightBase = 20;
if (BaseShape == null)
{
BaseShape = new Polygon();
BaseShape.Points.Add(new Point(-20, 25));
BaseShape.Points.Add(new Point(-20, 20));
BaseShape.Points.Add(new Point(0, 0));
BaseShape.Points.Add(new Point(20, 20));
BaseShape.Points.Add(new Point(20, 25));
}
PointCollection newShape = new PointCollection();
double maxValue = Windows.UI.Xaml.Window.Current.Bounds.Width;
if (BaseShape != null)
{
foreach (Point j in BaseShape.Points)
{
double shiftX = j.X;
if (valueAsDouble < LeftBase)
{
if (j.X < 0)
{
shiftX = j.X * valueAsDouble / LeftBase;
}
}
if ((maxValue - valueAsDouble) < RightBase)
{
if (j.X > 0)
{
shiftX = j.X * (maxValue - valueAsDouble) / RightBase;
}
}
newShape.Add(new Point(shiftX, j.Y));
}
}
return(newShape);
}
protected override void HandleNavigationHelperLoadState(object sender, LoadStateEventArgs e)
{
base.HandleNavigationHelperLoadState(sender, e);
object lastIndex;
if (e.PageState != null && e.PageState.TryGetValue("LIBRARY_PIVOT_INDEX", out lastIndex))
{
RootPivot.SelectedIndex = DebugHelper.CastAndAssert <int>(lastIndex);
}
songListRestoreHelper.LoadState(e.PageState);
albumListRestoreHelper.LoadState(e.PageState);
artistListRestoreHelper.LoadState(e.PageState);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
double valueAsDouble = DebugHelper.CastAndAssert <double>(value);
if (valueAsDouble < 0)
{
return(0);
}
if (valueAsDouble > FullTarget)
{
return(FullTarget);
}
return(FullTarget * valueAsDouble);
}
protected U GetModelField <U>(string modelProperty)
{
PropertyInfo propertyInfo = typeof(T).GetRuntimeProperty(modelProperty);
DebugHelper.Assert(new CallerInfo(), propertyInfo != null, "Model {0} does not contain property {1}", typeof(T), modelProperty);
if (propertyInfo != null)
{
return(DebugHelper.CastAndAssert <U>(propertyInfo.GetValue(rootModel)));
}
else
{
return(default(U));
}
}
private void HandleLowerTextBoxGotFocus(object sender, RoutedEventArgs e)
{
Transform stackPanelRestore = DebugHelper.CastAndAssert <Transform>(((TextBox)sender).TransformToVisual(rootStackPanel));
TranslateTransform shiftDown = new TranslateTransform();
shiftDown.Y = 90;
TransformGroup group = new TransformGroup();
group.Children.Add(DebugHelper.CastAndAssert <Transform>(stackPanelRestore.Inverse));
group.Children.Add(shiftDown);
rootStackPanel.RenderTransform = group;
}
private void HandleContentDialogPrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
var selectedItem = AddComboBox.SelectedItem;
if (selectedItem == null)
{
return;
}
PlaylistViewModel selectedPlaylist = DebugHelper.CastAndAssert <PlaylistViewModel>(selectedItem);
selectedPlaylistId = selectedPlaylist.PlaylistId;
selectedPlaylist.AddSong(Song);
}
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);
}
}
protected void SetModelField <U>(string modelProperty, U value, string property)
{
PropertyInfo propertyInfo = typeof(T).GetRuntimeProperty(modelProperty);
DebugHelper.Assert(new CallerInfo(), propertyInfo != null, "Model {0} does not contain property {1}", typeof(T), modelProperty);
if (propertyInfo != null)
{
U field = DebugHelper.CastAndAssert <U>(propertyInfo.GetValue(rootModel));
if (!EqualityComparer <U> .Default.Equals(field, value))
{
propertyInfo.SetValue(rootModel, value);
NotifyPropertyChanged(property);
}
}
}
protected void SetTableField <U>(string tableProperty, U value, string property)
{
PropertyInfo propertyInfo = typeof(T).GetRuntimeProperty(tableProperty);
DebugHelper.Assert(new CallerInfo(), propertyInfo != null, "Table {0} does not contain property {1}", typeof(T), tableProperty);
if (propertyInfo != null)
{
U field = DebugHelper.CastAndAssert <U>(propertyInfo.GetValue(rootTable));
if (!EqualityComparer <U> .Default.Equals(field, value))
{
propertyInfo.SetValue(rootTable, value);
DatabaseManager.Current.Update(rootTable);
NotifyPropertyChanged(property);
}
}
}
private void MixEntryType_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (MixEntryType.SelectedItem == null)
{
return;
}
SelectableOption <MixType> selectedType = DebugHelper.CastAndAssert <SelectableOption <MixType> >(MixEntryType.SelectedItem);
switch (selectedType.Type & MixType.TYPE_MASK)
{
case MixType.NUMBER_TYPE:
VisualStateManager.GoToState(this, "NumberSelected", false);
UpdateNumericState(selectedType.Type);
return;
case MixType.STRING_TYPE:
VisualStateManager.GoToState(this, "StringSelected", false);
return;
case MixType.NESTED_TYPE:
VisualStateManager.GoToState(this, "NestedSelected", false);
return;
case MixType.RANGE_TYPE:
VisualStateManager.GoToState(this, "RangeSelected", false);
return;
case MixType.MEMBER_TYPE:
VisualStateManager.GoToState(this, "MemberSelected", false);
UpdateMemberState(selectedType.Type);
return;
default:
DebugHelper.Assert(new CallerInfo(), selectedType.Type == MixType.None, "Unexpected mix type: {0}", selectedType.Type);
VisualStateManager.GoToState(this, "UnknownSelected", false);
return;
}
}
private void UpdateMargins()
{
double h = this.ActualHeight == 0 ? this.Height : this.ActualHeight;
double w = this.ActualWidth == 0 ? this.Width : this.ActualWidth;
double desiredHeight = h - 2 * InnerMargin;
double desiredWidth = w - 2 * InnerMargin;
SymbolTileScaleTransform.ScaleX = desiredHeight / 30.0;
SymbolTileScaleTransform.ScaleY = desiredWidth / 30.0;
// For some reason the visual states don't work... so giving up and doing this instead
if (w < 160)
{
CaptionTextBlock.Style = DebugHelper.CastAndAssert <Style>(Resources["TileTextStyleSmall"]);
}
else
{
CaptionTextBlock.Style = DebugHelper.CastAndAssert <Style>(Resources["TileTextStyle"]);
}
}
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;
}
}
private void HandleContentDialogPrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
if ((deleteMix.IsChecked.HasValue && deleteMix.IsChecked.Value) &&
(deleteMixConfirm.IsChecked.HasValue && deleteMixConfirm.IsChecked.Value))
{
LibraryViewModel.Current.DeleteMix(Mix);
}
else
{
Mix.Name = editMixName.Text;
if (mixLimitCheckBox.IsChecked.HasValue)
{
Mix.HasLimit = mixLimitCheckBox.IsChecked.Value;
}
uint newMixLimit;
if (uint.TryParse(mixLimitTextBox.Text, out newMixLimit))
{
Mix.Limit = newMixLimit;
}
if (mixHiddenCheckBox.IsChecked.HasValue)
{
Mix.IsHidden = mixHiddenCheckBox.IsChecked.Value;
}
SelectableOption <MixSortOrder> selectedType = DebugHelper.CastAndAssert <SelectableOption <MixSortOrder> >(SortTypeComboBox.SelectedItem);
SelectableOption <MixSortOrder> selectedOrder = DebugHelper.CastAndAssert <SelectableOption <MixSortOrder> >(SortOrderComboBox.SelectedItem);
Mix.SortType = selectedType.Type | selectedOrder.Type;
IMixEvaluator mixEval = RootMixEntry.ConvertToEvaluator();
Mix.SetEvaluator(mixEval);
Mix.Reset();
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
double valueAsDouble = DebugHelper.CastAndAssert <double>(value);
double target = FullTarget;
if (FullMode)
{
target = Windows.UI.Xaml.Window.Current.Bounds.Width;
}
if (valueAsDouble < 0)
{
return(0);
}
if (valueAsDouble > target)
{
return(target);
}
return(target * valueAsDouble);
}
internal void HandleContinuation(IContinuationActivatedEventArgs continuationEventArgs)
{
if (mainNavigationFrame != null && mainNavigationFrame.Content is AlbumPage)
{
if (continuationEventArgs is FileOpenPickerContinuationEventArgs)
{
AlbumPage currentAlbumPage = DebugHelper.CastAndAssert <AlbumPage>(mainNavigationFrame.Content);
FileOpenPickerContinuationEventArgs filePickerOpenArgs = DebugHelper.CastAndAssert <FileOpenPickerContinuationEventArgs>(continuationEventArgs);
currentAlbumPage.HandleFilePickerLaunch(filePickerOpenArgs);
}
}
else if (mainNavigationFrame != null && mainNavigationFrame.Content is ManageLibrary)
{
if (continuationEventArgs is FileOpenPickerContinuationEventArgs)
{
FileOpenPickerContinuationEventArgs filePickerOpenArgs = DebugHelper.CastAndAssert <FileOpenPickerContinuationEventArgs>(continuationEventArgs);
if (filePickerOpenArgs.Files.Count > 0)
{
DebugHelper.Assert(new CallerInfo(), filePickerOpenArgs.Files.Count == 1);
IStorageFile pickedFile = filePickerOpenArgs.Files[0];
MediaImportManager.Current.HandleFilePickerLaunch(pickedFile);
}
}
else if (continuationEventArgs is FolderPickerContinuationEventArgs)
{
FolderPickerContinuationEventArgs folderOpenArgs = DebugHelper.CastAndAssert <FolderPickerContinuationEventArgs>(continuationEventArgs);
if (folderOpenArgs.Folder != null)
{
MediaImportManager.Current.HandleSyncFolderLaunch(folderOpenArgs.Folder);
}
}
}
}
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);
}
}
