private void SetArtistInformation()
{
this.SlideDirection = SlideDirection.RightToLeft;
this.regionManager.RequestNavigate(RegionNames.NowPlayingContentRegion, typeof(NowPlayingScreenArtistInformation).FullName);
SettingsClient.Set <int>("FullPlayer", "SelectedNowPlayingPage", (int)SelectedNowPlayingPage.ArtistInformation);
isShowCaseVisible = false;
isPlaylistVisible = false;
isLyricsVisible = false;
isArtistInformationVisible = true;
}
public void GetPlayBackServiceShuffle()
{
// Important: set Shuffle directly, not the Shuffle Property,
// because there is no Shuffle Property Setter!
this.shuffle = this.playbackService.Shuffle;
RaisePropertyChanged(nameof(this.Shuffle));
// Save the Shuffle status in the Settings
SettingsClient.Set <bool>("Playback", "Shuffle", this.shuffle);
}
private void Window_Closing(object sender, CancelEventArgs e)
{
// Prevent the OOBE window from appearing the next time the application is started
SettingsClient.Set <bool>("General", "ShowOobe", false);
// Closing the OOBE window, must show the main window.
Application.Current.MainWindow.Show();
// We're closing the OOBE window, tell the IndexingService to start checking the collection.
this.indexingService.RefreshCollectionImmediatelyAsync();
}
private void MetroWindow_Closing(object sender, CancelEventArgs e)
{
// Prevent the Oobe window from appearing the next time the application is started
SettingsClient.Set <bool>("General", "ShowOobe", false);
// Closing the Oobe windows, must show the main window
Application.Current.MainWindow.Show();
// We're closing the OOBE screen, tell the IndexingService to start.
this.indexingService.IndexCollectionAsync(SettingsClient.Get <bool>("Indexing", "IgnoreRemovedFiles"), false);
}
private void SaveWindowSize()
{
if (this.allowSaveWindowGeometry)
{
if (!this.isMiniPlayer & !(this.WindowState == WindowState.Maximized))
{
SettingsClient.Set <int>("FullPlayer", "Width", Convert.ToInt32(this.ActualWidth));
SettingsClient.Set <int>("FullPlayer", "Height", Convert.ToInt32(this.ActualHeight));
}
}
}
public void SaveWindowSize(WindowState state, Size size)
{
if (this.canSaveWindowGeometry)
{
if (!this.isMiniPlayerActive & state != WindowState.Maximized)
{
SettingsClient.Set <int>("FullPlayer", "Width", Convert.ToInt32(size.Width));
SettingsClient.Set <int>("FullPlayer", "Height", Convert.ToInt32(size.Height));
}
}
}
public void SetMute(bool mute)
{
this.mute = mute;
if (this.player != null)
{
this.player.SetVolume(mute ? 0.0f : this.Volume);
}
SettingsClient.Set <bool>("Playback", "Mute", this.mute);
this.PlaybackMuteChanged(this, new EventArgs());
}
public void SaveWindowState(WindowState state)
{
this.WindowState = state;
// Only save window state when not in tablet mode. Tablet mode maximizes the screen.
// We don't want to save that, as we want to be able to restore to the original state when leaving tablet mode.
if (this.canSaveWindowGeometry & !this.windowsIntegrationService.IsTabletModeEnabled)
{
SettingsClient.Set <bool>("FullPlayer", "IsMaximized", state == WindowState.Maximized ? true : false);
}
this.WindowStateChanged(this, new WindowStateChangedEventArgs(state));
}
public void GetPlayBackServiceLoop()
{
// Important: set Loop directly, not the Loop Property,
// because there is no Loop Property Setter!
this.loopMode = this.playbackService.LoopMode;
RaisePropertyChanged(nameof(this.ShowLoopNone));
RaisePropertyChanged(nameof(this.ShowLoopOne));
RaisePropertyChanged(nameof(this.ShowLoopAll));
// Save the Loop status in the Settings
SettingsClient.Set <int>("Playback", "LoopMode", (int)this.loopMode);
}
public static void SetVisibleSongsColumns(bool ratingVisible, bool loveVisible, bool lyricsVisible, bool artistVisible, bool albumVisible, bool genreVisible, bool lengthVisible, bool albumArtistVisible, bool trackNumberVisible, bool yearVisible, bool bitrateVisible)
{
List <string> visibleColumns = new List <string>();
if (ratingVisible)
{
visibleColumns.Add("rating");
}
if (loveVisible)
{
visibleColumns.Add("love");
}
if (lyricsVisible)
{
visibleColumns.Add("lyrics");
}
if (artistVisible)
{
visibleColumns.Add("artist");
}
if (albumVisible)
{
visibleColumns.Add("album");
}
if (genreVisible)
{
visibleColumns.Add("genre");
}
if (lengthVisible)
{
visibleColumns.Add("length");
}
if (albumArtistVisible)
{
visibleColumns.Add("albumartist");
}
if (trackNumberVisible)
{
visibleColumns.Add("tracknumber");
}
if (yearVisible)
{
visibleColumns.Add("year");
}
if (bitrateVisible)
{
visibleColumns.Add("bitrate");
}
SettingsClient.Set <string>("TracksGrid", "VisibleColumns", string.Join(";", visibleColumns.ToArray()));
}
private void SaveWindowState()
{
if (this.allowSaveWindowGeometry)
{
if (this.WindowState == WindowState.Maximized)
{
SettingsClient.Set <bool>("FullPlayer", "IsMaximized", true);
}
else
{
SettingsClient.Set <bool>("FullPlayer", "IsMaximized", false);
}
}
}
public TracksViewModelBase(IContainerProvider container) : base(container)
{
// Dependency injection
this.container = container;
this.trackRepository = container.Resolve <ITrackRepository>();
this.dialogService = container.Resolve <IDialogService>();
this.searchService = container.Resolve <ISearchService>();
this.playbackService = container.Resolve <IPlaybackService>();
this.collectionService = container.Resolve <ICollectionService>();
this.i18nService = container.Resolve <II18nService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
this.providerService = container.Resolve <IProviderService>();
this.playlistService = container.Resolve <IPlaylistService>();
this.metadataService = container.Resolve <IMetadataService>();
// Events
this.metadataService.MetadataChanged += MetadataChangedHandlerAsync;
// Commands
this.ToggleTrackOrderCommand = new DelegateCommand(() => this.ToggleTrackOrder());
this.AddTracksToPlaylistCommand = new DelegateCommand <string>(async(playlistName) => await this.AddTracksToPlaylistAsync(playlistName, this.SelectedTracks));
this.PlaySelectedCommand = new DelegateCommand(async() => await this.PlaySelectedAsync());
this.PlayNextCommand = new DelegateCommand(async() => await this.PlayNextAsync());
this.AddTracksToNowPlayingCommand = new DelegateCommand(async() => await this.AddTracksToNowPlayingAsync());
this.RemoveSelectedTracksFromDiskCommand = new DelegateCommand(async() => await this.RemoveTracksFromDiskAsync(this.SelectedTracks), () => !this.IsIndexing);
this.UpdateShowTrackArtCommand = new DelegateCommand <bool?>((showTrackArt) =>
{
SettingsClient.Set <bool>("Appearance", "ShowTrackArtOnPlaylists", showTrackArt.Value, true);
});
// Settings changed
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Behaviour", "ShowRemoveFromDisk"))
{
RaisePropertyChanged(nameof(this.ShowRemoveFromDisk));
}
};
// Events
this.i18nService.LanguageChanged += (_, __) =>
{
RaisePropertyChanged(nameof(this.TotalDurationInformation));
RaisePropertyChanged(nameof(this.TotalSizeInformation));
this.RefreshLanguage();
};
this.playbackService.PlaybackCountersChanged += PlaybackService_PlaybackCountersChanged;
}
public PlaylistViewModelBase(IContainerProvider container) : base(container)
{
// Dependency injection
this.container = container;
this.playbackService = container.Resolve <IPlaybackService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
this.searchService = container.Resolve <ISearchService>();
this.dialogService = container.Resolve <IDialogService>();
this.providerService = container.Resolve <IProviderService>();
this.i18nService = container.Resolve <II18nService>();
// Commands
this.PlaySelectedCommand = new DelegateCommand(async() => await this.PlaySelectedAsync());
this.PlayNextCommand = new DelegateCommand(async() => await this.PlayNextAsync());
this.AddTracksToNowPlayingCommand = new DelegateCommand(async() => await this.AddTracksToNowPlayingAsync());
this.UpdateShowTrackArtCommand = new DelegateCommand <bool?>((showTrackArt) =>
{
SettingsClient.Set <bool>("Appearance", "ShowTrackArtOnPlaylists", showTrackArt.Value, true);
});
// Settings
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating"))
{
this.EnableRating = (bool)e.SettingValue;
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove"))
{
this.EnableLove = (bool)e.SettingValue;
}
};
// Events
this.i18nService.LanguageChanged += (_, __) => this.RefreshLanguage();
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowTrackArtOnPlaylists"))
{
this.ShowTrackArt = (bool)e.SettingValue;
this.UpdateShowTrackArtAsync();
}
};
// Settings
this.ShowTrackArt = SettingsClient.Get <bool>("Appearance", "ShowTrackArtOnPlaylists");
}
private void SaveWindowLocation()
{
if (this.canSaveWindowGeometry)
{
if (SettingsClient.Get <bool>("General", "IsMiniPlayer"))
{
SettingsClient.Set <int>("MiniPlayer", "Top", Convert.ToInt32(this.Top));
SettingsClient.Set <int>("MiniPlayer", "Left", Convert.ToInt32(this.Left));
}
else if (!SettingsClient.Get <bool>("General", "IsMiniPlayer") & !(this.WindowState == WindowState.Maximized))
{
SettingsClient.Set <int>("FullPlayer", "Top", Convert.ToInt32(this.Top));
SettingsClient.Set <int>("FullPlayer", "Left", Convert.ToInt32(this.Left));
}
}
}
private void SaveWindowLocation()
{
if (this.allowSaveWindowGeometry)
{
if (this.isMiniPlayer)
{
SettingsClient.Set <int>("MiniPlayer", "Top", Convert.ToInt32(this.Top));
SettingsClient.Set <int>("MiniPlayer", "Left", Convert.ToInt32(this.Left));
}
else if (!this.isMiniPlayer & !(this.WindowState == WindowState.Maximized))
{
SettingsClient.Set <int>("FullPlayer", "Top", Convert.ToInt32(this.Top));
SettingsClient.Set <int>("FullPlayer", "Left", Convert.ToInt32(this.Left));
}
}
}
public void SaveWindowLocation(double top, double left, WindowState state)
{
if (this.canSaveWindowGeometry)
{
if (this.isMiniPlayerActive)
{
SettingsClient.Set <int>("MiniPlayer", "Top", Convert.ToInt32(top));
SettingsClient.Set <int>("MiniPlayer", "Left", Convert.ToInt32(left));
}
else if (state != WindowState.Maximized)
{
SettingsClient.Set <int>("FullPlayer", "Top", Convert.ToInt32(top));
SettingsClient.Set <int>("FullPlayer", "Left", Convert.ToInt32(left));
}
}
}
private async Task BackupAsync()
{
bool isBackupSuccess = false;
// Choose a backup file
string backupFile = string.Empty;
bool isBackupFileChosen = this.SaveBackupFile(ref backupFile);
if (!isBackupFileChosen)
{
return;
}
// Close all note windows
await this.noteService.CloseAllNoteWindowsAsync(500);
// Perform the backup to file
isBackupSuccess = this.backupService.Backup(backupFile);
// Update LastBackupDirectory setting
if (isBackupSuccess)
{
SettingsClient.Set <string>("General", "LastBackupDirectory", Path.GetDirectoryName(backupFile));
}
if (isBackupSuccess)
{
// Show notification if backup succeeded
this.dialogService.ShowNotificationDialog(
null,
title: ResourceUtils.GetStringResource("Language_Success"),
content: ResourceUtils.GetStringResource("Language_Backup_Was_Successful"),
okText: ResourceUtils.GetStringResource("Language_Ok"),
showViewLogs: false);
}
else
{
// Show error if backup failed
this.dialogService.ShowNotificationDialog(
null,
title: ResourceUtils.GetStringResource("Language_Error"),
content: ResourceUtils.GetStringResource("Language_Error_Backup_Error"),
okText: ResourceUtils.GetStringResource("Language_Ok"),
showViewLogs: true);
}
}
private void NagivateToSelectedPage(FullPlayerPage page)
{
this.SlideInFrom = page <= this.previousSelectedPage ? -Constants.SlideDistance : Constants.SlideDistance;
this.previousSelectedPage = page;
switch (page)
{
case FullPlayerPage.Collection:
this.regionManager.RequestNavigate(RegionNames.FullPlayerRegion, typeof(Views.FullPlayer.Collection.Collection).FullName);
this.regionManager.RequestNavigate(RegionNames.FullPlayerMenuRegion, typeof(Views.FullPlayer.Collection.CollectionMenu).FullName);
this.ShowBackButton = false;
this.goBackPage = FullPlayerPage.Collection;
SettingsClient.Set <int>("FullPlayer", "SelectedPage", (int)FullPlayerPage.Collection);
break;
case FullPlayerPage.Playlists:
this.regionManager.RequestNavigate(RegionNames.FullPlayerRegion, typeof(Views.FullPlayer.Playlists.Playlists).FullName);
this.regionManager.RequestNavigate(RegionNames.FullPlayerMenuRegion, typeof(Views.FullPlayer.Playlists.PlaylistsMenu).FullName);
this.ShowBackButton = false;
this.goBackPage = FullPlayerPage.Playlists;
SettingsClient.Set <int>("FullPlayer", "SelectedPage", (int)FullPlayerPage.Playlists);
break;
case FullPlayerPage.Settings:
this.regionManager.RequestNavigate(RegionNames.FullPlayerRegion, typeof(Views.FullPlayer.Settings.Settings).FullName);
this.regionManager.RequestNavigate(RegionNames.FullPlayerMenuRegion, typeof(Views.FullPlayer.Settings.SettingsMenu).FullName);
this.ShowBackButton = true;
break;
case FullPlayerPage.Information:
this.regionManager.RequestNavigate(RegionNames.FullPlayerRegion, typeof(Views.FullPlayer.Information.Information).FullName);
this.regionManager.RequestNavigate(RegionNames.FullPlayerMenuRegion, typeof(Views.FullPlayer.Information.InformationMenu).FullName);
this.ShowBackButton = true;
break;
default:
break;
}
if (page != FullPlayerPage.Settings)
{
this.indexingService.RefreshCollectionIfFoldersChangedAsync();
}
}
private async Task ToggleGenreOrderAsync()
{
switch (this.GenreOrder)
{
case GenreOrder.Alphabetical:
this.GenreOrder = GenreOrder.ReverseAlphabetical;
break;
case GenreOrder.ReverseAlphabetical:
this.GenreOrder = GenreOrder.Alphabetical;
break;
default:
// Cannot happen, but just in case.
this.GenreOrder = GenreOrder.Alphabetical;
break;
}
SettingsClient.Set <int>("Ordering", "GenresGenreOrder", (int)this.GenreOrder);
await this.GetGenresCommonAsync(this.Genres.Select((g) => ((GenreViewModel)g).Genre).ToList(), this.GenreOrder);
}
private async void Shell_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
LogClient.Info("### STOPPING {0}, version {1} ###", ProductInformation.ApplicationName, ProcessExecutable.AssemblyVersion().ToString());
// Prevent saving the size when the window is minimized.
// When minimized, the actual size is not detected correctly,
// which causes a too small size to be saved.
if (!(this.WindowState == WindowState.Minimized))
{
if (this.WindowState == WindowState.Maximized)
{
SettingsClient.Set <bool>("General", "IsMaximized", true);
}
else
{
SettingsClient.Set <bool>("General", "IsMaximized", false);
// TODO: make tis better. Workaround for bug "MainWindow opens with size 0 px"
if (this.ActualWidth > 50 & this.ActualHeight > 50)
{
SettingsClient.Set <int>("General", "Width", (int)this.ActualWidth);
SettingsClient.Set <int>("General", "Height", (int)this.ActualHeight);
}
else
{
SettingsClient.Set <int>("General", "Width", Defaults.DefaultMainWindowWidth);
SettingsClient.Set <int>("General", "Height", Defaults.DefaultMainWindowHeight);
}
SettingsClient.Set <int>("General", "Top", (int)this.Top);
SettingsClient.Set <int>("General", "Left", (int)this.Left);
}
// Save the settings immediately
SettingsClient.Write();
}
await this.noteService.CloseAllNoteWindowsAsync();
}
private void ApplyManualPreset()
{
if (!this.canApplyManualPreset)
{
return;
}
EqualizerPreset manualPreset = this.Presets.Select((p) => p).Where((p) => p.Name == Defaults.ManualPresetName).FirstOrDefault();
manualPreset.Load(this.Band0, this.Band1, this.Band2, this.Band3, this.Band4, this.Band5, this.Band6, this.Band7, this.Band8, this.Band9);
SettingsClient.Set <string>("Equalizer", "ManualPreset", manualPreset.ToValueString());
// Once a slider has moved, revert to the manual preset (also in the settings).
if (this.SelectedPreset.Name != Defaults.ManualPresetName)
{
this.SelectedPreset = manualPreset;
SettingsClient.Set <string>("Equalizer", "SelectedPreset", Defaults.ManualPresetName);
}
this.playbackService.ApplyPreset(manualPreset);
}
public MiniPlayerViewModelBase(IContainerProvider container) : base(container)
{
// Commands
this.ChangePlayerTypeCommand = new DelegateCommand <string>(miniPlayerType => this.SetPlayerContextMenuCheckBoxes((MiniPlayerType)(int.Parse(miniPlayerType))));
ApplicationCommands.ChangePlayerTypeCommand.RegisterCommand(this.ChangePlayerTypeCommand);
this.ToggleMiniPlayerPositionLockedCommand = new DelegateCommand(() =>
{
IsMiniPlayerPositionLocked = !IsMiniPlayerPositionLocked;
SettingsClient.Set <bool>("Behaviour", "MiniPlayerPositionLocked", IsMiniPlayerPositionLocked);
});
ApplicationCommands.ToggleMiniPlayerPositionLockedCommand.RegisterCommand(this.ToggleMiniPlayerPositionLockedCommand);
this.ToggleMiniPlayerAlwaysOnTopCommand = new DelegateCommand(() =>
{
this.IsMiniPlayerAlwaysOnTop = !this.IsMiniPlayerAlwaysOnTop;
SettingsClient.Set <bool>("Behaviour", "MiniPlayerOnTop", this.IsMiniPlayerAlwaysOnTop);
});
ApplicationCommands.ToggleMiniPlayerAlwaysOnTopCommand.RegisterCommand(this.ToggleMiniPlayerAlwaysOnTopCommand);
//Initialize
this.Initialize();
}
private void SetSpectrumStyle(SpectrumStyle style)
{
switch (style)
{
case SpectrumStyle.Flames:
this.SpectrumStyleFlames();
break;
case SpectrumStyle.Lines:
this.SpectrumStyleLines();
break;
case SpectrumStyle.Bars:
this.SpectrumStyleBars();
break;
default:
this.SpectrumStyleFlames();
break;
}
SettingsClient.Set <int>("Playback", "SpectrumStyle", (int)style);
}
protected async override Task SetCoversizeAsync(CoverSizeType iCoverSize)
{
await base.SetCoversizeAsync(iCoverSize);
SettingsClient.Set <int>("CoverSizes", "AlbumsCoverSize", (int)iCoverSize);
}
private void SetSpectrumStyle(SpectrumStyle style)
{
switch (style)
{
case SpectrumStyle.Flames:
this.SpectrumStyle = SpectrumStyle.Flames;
this.BlurRadius = 20;
this.SpectrumBarCount = 65;
this.SpectrumWidth = 270;
this.SpectrumBarWidth = 4;
this.SpectrumBarSpacing = 0;
this.SpectrumPanelHeight = 60;
this.SpectrumOpacity = 0.65;
this.AnimationStyle = SpectrumAnimationStyle.Gentle;
//var accentColor = (Color)Application.Current.TryFindResource("RG_AccentColor");
//var gradientColor = HSLColor.GetFromRgb(accentColor).MoveNext(40).ToRgb();
//this.SpectrumBarBackground = new LinearGradientBrush(new GradientStopCollection()
//{
// new GradientStop(accentColor, 0),
// new GradientStop(accentColor, 0.45),
// new GradientStop(gradientColor, 1),
//}, new Point(0.5, 1), new Point(0.5, 0));
this.SpectrumBarBackground = (Brush)Application.Current.TryFindResource("RG_AccentBrush");
break;
case SpectrumStyle.Lines:
this.SpectrumStyle = SpectrumStyle.Lines;
this.BlurRadius = 0;
this.SpectrumBarCount = 50;
this.SpectrumWidth = 162;
this.SpectrumBarWidth = 1;
this.SpectrumBarSpacing = 2;
this.SpectrumPanelHeight = 30;
this.SpectrumOpacity = 1.0;
this.AnimationStyle = SpectrumAnimationStyle.Nervous;
this.SpectrumBarBackground = (Brush)Application.Current.TryFindResource("RG_AccentBrush");
break;
case SpectrumStyle.Bars:
this.SpectrumStyle = SpectrumStyle.Bars;
this.BlurRadius = 0;
this.SpectrumBarCount = 20;
this.SpectrumWidth = 162;
this.SpectrumBarWidth = 6;
this.SpectrumBarSpacing = 2;
this.SpectrumPanelHeight = 30;
this.SpectrumOpacity = 1.0;
this.AnimationStyle = SpectrumAnimationStyle.Nervous;
this.SpectrumBarBackground = (Brush)Application.Current.TryFindResource("RG_AccentBrush");
break;
case SpectrumStyle.Stripes:
this.SpectrumStyle = SpectrumStyle.Stripes;
this.BlurRadius = 0;
this.SpectrumBarCount = 13;
this.SpectrumWidth = 162;
this.SpectrumBarWidth = 10;
this.SpectrumBarSpacing = 2;
this.SpectrumPanelHeight = 30;
this.SpectrumOpacity = 1.0;
this.AnimationStyle = SpectrumAnimationStyle.Nervous;
this.SpectrumBarBackground = (Brush)Application.Current.TryFindResource("RG_AccentStripedBrush");
break;
default:
// Shouldn't happen
break;
}
SettingsClient.Set <int>("Playback", "SpectrumStyle", (int)style);
}
private void InitializeCommands()
{
// TaskbarItemInfo
// ---------------
TaskbarItemInfoPlayCommand = new DelegateCommand(async() => await this.playbackService.PlayOrPauseAsync());
Common.Prism.ApplicationCommands.TaskbarItemInfoPlayCommand.RegisterCommand(this.TaskbarItemInfoPlayCommand);
// Window State
// ------------
this.MinimizeWindowCommand = new DelegateCommand(() => this.WindowState = WindowState.Minimized);
Common.Prism.ApplicationCommands.MinimizeWindowCommand.RegisterCommand(this.MinimizeWindowCommand);
this.RestoreWindowCommand = new DelegateCommand(() => this.SetPlayer(false, MiniPlayerType.CoverPlayer));
Common.Prism.ApplicationCommands.RestoreWindowCommand.RegisterCommand(this.RestoreWindowCommand);
this.MaximizeRestoreWindowCommand = new DelegateCommand(() =>
{
if (this.WindowState == WindowState.Maximized)
{
this.WindowState = WindowState.Normal;
}
else
{
this.WindowState = WindowState.Maximized;
}
});
Common.Prism.ApplicationCommands.MaximizeRestoreWindowCommand.RegisterCommand(this.MaximizeRestoreWindowCommand);
this.CloseWindowCommand = new DelegateCommand(() => this.Close());
Common.Prism.ApplicationCommands.CloseWindowCommand.RegisterCommand(this.CloseWindowCommand);
// Player type
// -----------
this.ChangePlayerTypeCommand = new DelegateCommand <string>((miniPlayerType) => this.SetPlayer(true, (MiniPlayerType)Convert.ToInt32(miniPlayerType)));
Common.Prism.ApplicationCommands.ChangePlayerTypeCommand.RegisterCommand(this.ChangePlayerTypeCommand);
this.TogglePlayerCommand = new DelegateCommand(() =>
{
// If tablet mode is enabled, we should not be able to toggle the player.
if (!this.IsTabletModeEnabled())
{
this.TogglePlayer();
}
});
Common.Prism.ApplicationCommands.TogglePlayerCommand.RegisterCommand(this.TogglePlayerCommand);
// Mini Player
// -----------
this.isMiniPlayerPositionLocked = SettingsClient.Get <bool>("Behaviour", "MiniPlayerPositionLocked");
this.isMiniPlayerAlwaysOnTop = SettingsClient.Get <bool>("Behaviour", "MiniPlayerOnTop");
this.ToggleMiniPlayerPositionLockedCommand = new DelegateCommand(() =>
{
this.isMiniPlayerPositionLocked = !isMiniPlayerPositionLocked;
this.SetWindowPositionLocked(isMiniPlayer);
});
Common.Prism.ApplicationCommands.ToggleMiniPlayerPositionLockedCommand.RegisterCommand(this.ToggleMiniPlayerPositionLockedCommand);
this.ToggleMiniPlayerAlwaysOnTopCommand = new DelegateCommand(() =>
{
this.isMiniPlayerAlwaysOnTop = !this.isMiniPlayerAlwaysOnTop;
this.SetWindowAlwaysOnTop(this.isMiniPlayer);
});
Common.Prism.ApplicationCommands.ToggleMiniPlayerAlwaysOnTopCommand.RegisterCommand(this.ToggleMiniPlayerAlwaysOnTopCommand);
// Screens
// -------
this.NavigateToMainScreenCommand = new DelegateCommand(() =>
{
this.regionManager.RequestNavigate(RegionNames.ScreenTypeRegion, typeof(MainScreen).FullName);
SettingsClient.Set <bool>("FullPlayer", "IsNowPlayingSelected", false);
this.eventAggregator.GetEvent <NowPlayingIsSelectedChanged>().Publish(false);
});
Common.Prism.ApplicationCommands.NavigateToMainScreenCommand.RegisterCommand(this.NavigateToMainScreenCommand);
this.NavigateToNowPlayingScreenCommand = new DelegateCommand(() =>
{
this.regionManager.RequestNavigate(RegionNames.ScreenTypeRegion, typeof(NowPlayingScreen).FullName);
SettingsClient.Set <bool>("FullPlayer", "IsNowPlayingSelected", true);
this.eventAggregator.GetEvent <NowPlayingIsSelectedChanged>().Publish(true);
});
Common.Prism.ApplicationCommands.NavigateToNowPlayingScreenCommand.RegisterCommand(this.NavigateToNowPlayingScreenCommand);
// Application
// -----------
this.ShowMainWindowCommand = new DelegateCommand(() => TrayIconContextMenuAppName_Click(null, null));
Common.Prism.ApplicationCommands.ShowMainWindowCommand.RegisterCommand(this.ShowMainWindowCommand);
}
public void OnNavigatedTo(NavigationContext navigationContext)
{
this.Subscribe();
SettingsClient.Set <int>("FullPlayer", "SelectedPage", (int)SelectedPage.Artists);
}
public ShellService(IRegionManager regionManager, IWindowsIntegrationService windowsIntegrationService, IEventAggregator eventAggregator,
string nowPlayingPage, string fullPlayerPage, string coverPlayerPage, string microplayerPage, string nanoPlayerPage)
{
this.regionManager = regionManager;
this.windowsIntegrationService = windowsIntegrationService;
this.eventAggregator = eventAggregator;
this.nowPlayingPage = nowPlayingPage;
this.fullPlayerPage = fullPlayerPage;
this.coverPlayerPage = coverPlayerPage;
this.microplayerPage = microplayerPage;
this.nanoPlayerPage = nanoPlayerPage;
this.ShowNowPlayingCommand = new DelegateCommand(() =>
{
this.regionManager.RequestNavigate(RegionNames.PlayerTypeRegion, this.nowPlayingPage);
SettingsClient.Set <bool>("FullPlayer", "IsNowPlayingSelected", true);
this.eventAggregator.GetEvent <IsNowPlayingPageActiveChanged>().Publish(true);
});
ApplicationCommands.ShowNowPlayingCommand.RegisterCommand(this.ShowNowPlayingCommand);
this.ShowFullPlayerCommmand = new DelegateCommand(() =>
{
this.regionManager.RequestNavigate(RegionNames.PlayerTypeRegion, this.fullPlayerPage);
SettingsClient.Set <bool>("FullPlayer", "IsNowPlayingSelected", false);
this.eventAggregator.GetEvent <IsNowPlayingPageActiveChanged>().Publish(false);
});
ApplicationCommands.ShowFullPlayerCommand.RegisterCommand(this.ShowFullPlayerCommmand);
// Window state
this.WindowState = SettingsClient.Get <bool>("FullPlayer", "IsMaximized") ? WindowState.Maximized : WindowState.Normal;
// Player type
this.ChangePlayerTypeCommand = new DelegateCommand <string>((miniPlayerType) =>
this.SetPlayer(true, (MiniPlayerType)Convert.ToInt32(miniPlayerType)));
ApplicationCommands.ChangePlayerTypeCommand.RegisterCommand(this.ChangePlayerTypeCommand);
this.TogglePlayerCommand = new DelegateCommand(() =>
{
// If tablet mode is enabled, we should not be able to toggle the player.
if (!this.windowsIntegrationService.IsTabletModeEnabled)
{
this.TogglePlayer();
}
});
ApplicationCommands.TogglePlayerCommand.RegisterCommand(this.TogglePlayerCommand);
// Mini Player Playlist
this.CoverPlayerPlaylistButtonCommand = new DelegateCommand <bool?>(isPlaylistButtonChecked =>
{
this.ToggleMiniPlayerPlaylist(MiniPlayerType.CoverPlayer, isPlaylistButtonChecked.Value);
});
ApplicationCommands.CoverPlayerPlaylistButtonCommand.RegisterCommand(this.CoverPlayerPlaylistButtonCommand);
this.MicroPlayerPlaylistButtonCommand = new DelegateCommand <bool?>(isPlaylistButtonChecked =>
{
this.ToggleMiniPlayerPlaylist(MiniPlayerType.MicroPlayer, isPlaylistButtonChecked.Value);
});
ApplicationCommands.MicroPlayerPlaylistButtonCommand.RegisterCommand(this.MicroPlayerPlaylistButtonCommand);
this.NanoPlayerPlaylistButtonCommand = new DelegateCommand <bool?>(isPlaylistButtonChecked =>
{
this.ToggleMiniPlayerPlaylist(MiniPlayerType.NanoPlayer, isPlaylistButtonChecked.Value);
});
ApplicationCommands.NanoPlayerPlaylistButtonCommand.RegisterCommand(this.NanoPlayerPlaylistButtonCommand);
// Mini Player
this.ToggleMiniPlayerPositionLockedCommand = new DelegateCommand(() =>
{
bool isMiniPlayerPositionLocked = SettingsClient.Get <bool>("Behaviour", "MiniPlayerPositionLocked");
SettingsClient.Set <bool>("Behaviour", "MiniPlayerPositionLocked", !isMiniPlayerPositionLocked);
this.SetWindowPositionLockedFromSettings();
});
ApplicationCommands.ToggleMiniPlayerPositionLockedCommand.RegisterCommand(this.ToggleMiniPlayerPositionLockedCommand);
this.ToggleMiniPlayerAlwaysOnTopCommand = new DelegateCommand(() =>
{
bool topmost = SettingsClient.Get <bool>("Behaviour", "MiniPlayerOnTop");
SettingsClient.Set <bool>("Behaviour", "MiniPlayerOnTop", !topmost);
this.SetWindowTopmostFromSettings();
});
ApplicationCommands.ToggleMiniPlayerAlwaysOnTopCommand.RegisterCommand(this.ToggleMiniPlayerAlwaysOnTopCommand);
}
protected async override Task SetCoversizeAsync(CoverSizeType coverSize)
{
await base.SetCoversizeAsync(coverSize);
SettingsClient.Set <int>("CoverSizes", "GenresCoverSize", (int)coverSize);
}
public void OnNavigatedTo(NavigationContext navigationContext)
{
SettingsClient.Set <int>("FullPlayer", "SelectedPage", (int)SelectedPage.Recent);
}
