public CollectionPlaylistsViewModel(IContainerProvider container, IDialogService dialogService, IPlaybackService playbackService, IPlaylistService playlistService, IFileService fileService, IEventAggregator eventAggregator) : base(container) { this.dialogService = dialogService; this.playlistService = playlistService; this.playbackService = playbackService; this.fileService = fileService; this.eventAggregator = eventAggregator; this.dialogService = dialogService; // Events this.playlistService.PlaylistFolderChanged += PlaylistService_PlaylistFolderChanged; this.playlistService.TracksAdded += PlaylistService_TracksAdded; this.playlistService.TracksDeleted += PlaylistService_TracksDeleted; // Commands this.RenameSelectedPlaylistCommand = new DelegateCommand(async() => await this.RenameSelectedPlaylistAsync()); this.DeletePlaylistCommand = new DelegateCommand <PlaylistViewModel>(async(playlist) => await this.ConfirmDeletePlaylistAsync(playlist)); this.ImportPlaylistsCommand = new DelegateCommand(async() => await this.ImportPlaylistsAsync()); this.AddPlaylistToNowPlayingCommand = new DelegateCommand(async() => await this.AddPlaylistToNowPlayingAsync()); this.ShuffleSelectedPlaylistCommand = new DelegateCommand(async() => await this.ShuffleSelectedPlaylistAsync()); this.LoadedCommand = new DelegateCommand(async() => await this.LoadedCommandAsync()); this.NewPlaylistCommand = new DelegateCommand(async() => await this.ConfirmCreateNewPlaylistAsync()); this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.DeleteTracksFromPlaylistsAsync()); this.DeleteSelectedPlaylistCommand = new DelegateCommand(async() => { if (this.IsPlaylistSelected) { await this.ConfirmDeletePlaylistAsync(this.SelectedPlaylist); } }); // Settings changed 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; } }; // Load settings this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "PlaylistsLeftPaneWidthPercent"); }
public async Task <EqualizerPreset> GetSelectedPresetAsync() { var presets = await this.GetPresetsAsync(); string selectedPresetName = SettingsClient.Get <string>("Equalizer", "SelectedPreset"); EqualizerPreset selectedPreset = presets.Select((p) => p).Where((p) => p.Name == selectedPresetName).FirstOrDefault(); if (selectedPreset == null) { selectedPreset = new EqualizerPreset(Defaults.ManualPresetName, false); } return(selectedPreset); }
private async void Initialize() { // PlayerFactory this.playerFactory = new PlayerFactory(); // Settings this.SetPlaybackSettings(); // Equalizer await this.SetIsEqualizerEnabledAsync(SettingsClient.Get <bool>("Equalizer", "IsEnabled")); // Queued tracks this.GetSavedQueuedTracks(); }
public CommonViewModelBase(IContainerProvider container) : base(container) { // Dependency injection this.container = container; this.eventAggregator = container.Resolve <IEventAggregator>(); this.indexingService = container.Resolve <IIndexingService>(); this.playbackService = container.Resolve <IPlaybackService>(); this.searchService = container.Resolve <ISearchService>(); this.dialogService = container.Resolve <IDialogService>(); this.collectionService = container.Resolve <ICollectionService>(); this.metadataService = container.Resolve <IMetadataService>(); this.i18nService = container.Resolve <II18nService>(); this.playlistService = container.Resolve <IPlaylistService>(); this.foldersService = container.Resolve <IFoldersService>(); // Commands this.ShowSelectedTrackInformationCommand = new DelegateCommand(() => this.ShowSelectedTrackInformation()); this.SelectedTracksCommand = new DelegateCommand <object>((parameter) => this.SelectedTracksHandler(parameter)); this.EditTracksCommand = new DelegateCommand(() => this.EditSelectedTracks(), () => !this.IsIndexing); this.LoadedCommand = new DelegateCommand(async() => await this.LoadedCommandAsync()); this.UnloadedCommand = new DelegateCommand(async() => await this.UnloadedCommandAsync()); this.ShuffleAllCommand = new DelegateCommand(() => this.playbackService.EnqueueAsync(true, false)); // Events this.playbackService.PlaybackFailed += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackPaused += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackResumed += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackStopped += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackSuccess += (_, __) => this.ShowPlayingTrackAsync(); this.collectionService.CollectionChanged += async(_, __) => await this.FillListsAsync(); // Refreshes the lists when the Collection has changed this.foldersService.FoldersChanged += async(_, __) => await this.FillListsAsync(); // Refreshes the lists when marked folders have changed this.indexingService.RefreshLists += async(_, __) => await this.FillListsAsync(); // Refreshes the lists when the indexer has finished indexing this.indexingService.IndexingStarted += (_, __) => this.SetEditCommands(); this.indexingService.IndexingStopped += (_, __) => this.SetEditCommands(); this.searchService.DoSearch += (searchText) => this.FilterLists(); this.metadataService.RatingChanged += MetadataService_RatingChangedAsync; this.metadataService.LoveChanged += MetadataService_LoveChangedAsync; // Flags this.EnableRating = SettingsClient.Get <bool>("Behaviour", "EnableRating"); this.EnableLove = SettingsClient.Get <bool>("Behaviour", "EnableLove"); // This makes sure the IsIndexing is correct even when this ViewModel is // created after the Indexer is started, and thus after triggering the // IndexingService.IndexerStarted event. this.SetEditCommands(); }
private async void GetCheckBoxesAsync() { await Task.Run(() => { this.checkBoxShowTrayIconChecked = SettingsClient.Get <bool>("Behaviour", "ShowTrayIcon"); this.checkBoxMinimizeToTrayChecked = SettingsClient.Get <bool>("Behaviour", "MinimizeToTray"); this.checkBoxCloseToTrayChecked = SettingsClient.Get <bool>("Behaviour", "CloseToTray"); this.checkBoxFollowTrackChecked = SettingsClient.Get <bool>("Behaviour", "FollowTrack"); this.checkBoxEnableRatingChecked = SettingsClient.Get <bool>("Behaviour", "EnableRating"); this.checkBoxEnableLoveChecked = SettingsClient.Get <bool>("Behaviour", "EnableLove"); this.checkBoxShowRemoveFromDiskChecked = SettingsClient.Get <bool>("Behaviour", "ShowRemoveFromDisk"); this.checkBoxSaveRatingInAudioFilesChecked = SettingsClient.Get <bool>("Behaviour", "SaveRatingToAudioFiles"); }); }
private async void GetCheckBoxesAsync() { await Task.Run(() => { this.checkBoxThemeChecked = SettingsClient.Get <bool>("Appearance", "EnableLightTheme"); this.RaisePropertyChanged(nameof(this.CheckBoxThemeChecked)); this.checkBoxWindowsColorChecked = SettingsClient.Get <bool>("Appearance", "FollowWindowsColor"); this.RaisePropertyChanged(nameof(this.CheckBoxWindowsColorChecked)); this.checkBoxAlbumCoverColorChecked = SettingsClient.Get <bool>("Appearance", "FollowAlbumCoverColor"); this.RaisePropertyChanged(nameof(this.CheckBoxAlbumCoverColorChecked)); }); }
private void Window_StateChanged(object sender, System.EventArgs e) { if (this.WindowState == WindowState.Minimized) { if (SettingsClient.Get <bool>("Behaviour", "ShowTrayIcon") & SettingsClient.Get <bool>("Behaviour", "MinimizeToTray")) { // When minimizing to tray, hide this window from Taskbar and ALT-TAB menu. this.ShowInTaskbar = false; try { WindowUtils.HideWindowFromAltTab(this); } catch (Exception ex) { LogClient.Error("Could not hide main window from ALT-TAB menu. Exception: {0}", ex.Message); } } } else { if (this.WindowState == WindowState.Maximized) { try { WindowUtils.RemoveWindowCaption(this); } catch (Exception ex) { LogClient.Error("Could not remove window caption. Exception: {0}", ex.Message); } } // When restored, show this window in Taskbar and ALT-TAB menu. this.ShowInTaskbar = true; try { WindowUtils.ShowWindowInAltTab(this); } catch (Exception ex) { LogClient.Error("Could not show main window in ALT-TAB menu. Exception: {0}", ex.Message); } } this.SetWindowBorder(); this.shellService.SaveWindowState(this.WindowState); }
protected void SetTrackOrder(string settingName) { TrackOrder savedTrackOrder = (TrackOrder)SettingsClient.Get<int>("Ordering", settingName); if ((!this.EnableRating & savedTrackOrder == TrackOrder.ByRating) | (!this.CanOrderByAlbum & savedTrackOrder == TrackOrder.ByAlbum)) { this.TrackOrder = TrackOrder.Alphabetical; } else { // Only change the TrackOrder if it is not correct if (this.TrackOrder != savedTrackOrder) this.TrackOrder = savedTrackOrder; } }
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"); }
public TaskbarService(IPlaybackService playbackService) { this.playbackService = playbackService; this.ShowTaskBarItemInfoPause(false); // When starting, we're not playing yet. this.playbackService.PlaybackFailed += (_, __) => { this.Description = ProductInformation.ApplicationName; this.SetTaskbarProgressState(SettingsClient.Get <bool>("Playback", "ShowProgressInTaskbar"), this.playbackService.IsPlaying); this.ShowTaskBarItemInfoPause(false); }; this.playbackService.PlaybackPaused += (_, __) => { this.SetTaskbarProgressState(SettingsClient.Get <bool>("Playback", "ShowProgressInTaskbar"), this.playbackService.IsPlaying); this.ShowTaskBarItemInfoPause(false); }; this.playbackService.PlaybackResumed += (_, __) => { this.SetTaskbarProgressState(SettingsClient.Get <bool>("Playback", "ShowProgressInTaskbar"), this.playbackService.IsPlaying); this.ShowTaskBarItemInfoPause(true); }; this.playbackService.PlaybackStopped += (_, __) => { this.Description = ProductInformation.ApplicationName; this.SetTaskbarProgressState(false, false); this.ShowTaskBarItemInfoPause(false); }; this.playbackService.PlaybackSuccess += (_, __) => { if (!string.IsNullOrWhiteSpace(this.playbackService.CurrentTrack.Value.ArtistName) && !string.IsNullOrWhiteSpace(this.playbackService.CurrentTrack.Value.TrackTitle)) { this.Description = this.playbackService.CurrentTrack.Value.ArtistName + " - " + this.playbackService.CurrentTrack.Value.TrackTitle; } else { this.Description = this.playbackService.CurrentTrack.Value.FileName; } this.SetTaskbarProgressState(SettingsClient.Get <bool>("Playback", "ShowProgressInTaskbar"), this.playbackService.IsPlaying); this.ShowTaskBarItemInfoPause(true); }; this.playbackService.PlaybackProgressChanged += (_, __) => { this.ProgressValue = this.playbackService.Progress; }; }
private async void AddArtworkInBackgroundAsync() { // First, add artwork from file. await this.AddArtworkInBackgroundAsync(1); // Next, add artwork from the Internet, if the user has chosen to do so. if (SettingsClient.Get <bool>("Covers", "DownloadMissingAlbumCovers")) { // Add artwork from the Internet. await this.AddArtworkInBackgroundAsync(2); } // We don't need to scan for artwork anymore await this.trackRepository.DisableNeedsAlbumArtworkIndexingForAllTracksAsync(); }
private void SetPlaybackSettings() { this.isLoadingSettings = true; this.UseAllAvailableChannels = SettingsClient.Get <bool>("Playback", "WasapiUseAllAvailableChannels"); this.LoopMode = (LoopMode)SettingsClient.Get <int>("Playback", "LoopMode"); this.Latency = SettingsClient.Get <int>("Playback", "AudioLatency"); this.Volume = SettingsClient.Get <float>("Playback", "Volume"); this.mute = SettingsClient.Get <bool>("Playback", "Mute"); this.shuffle = SettingsClient.Get <bool>("Playback", "Shuffle"); this.EventMode = false; //this.EventMode = SettingsClient.Get<bool>("Playback", "WasapiEventMode"); //this.ExclusiveMode = false; this.ExclusiveMode = SettingsClient.Get <bool>("Playback", "WasapiExclusiveMode"); this.isLoadingSettings = false; }
public TracksViewModelBaseWithTrackArt(IContainerProvider container) : base(container) { // Settings changed SettingsClient.SettingChanged += (_, e) => { if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowTrackArtOnPlaylists")) { this.ShowTrackArt = (bool)e.SettingValue; this.UpdateShowTrackArtAsync(); } }; // Load settings this.ShowTrackArt = SettingsClient.Get <bool>("Appearance", "ShowTrackArtOnPlaylists"); }
public CollectionAlbumsViewModel(IContainerProvider container) : base(container) { // Dependency injection this.indexingService = container.Resolve <IIndexingService>(); this.collectionService = container.Resolve <ICollectionService>(); this.metadataService = container.Resolve <IMetadataService>(); this.eventAggregator = container.Resolve <IEventAggregator>(); // Settings SettingsClient.SettingChanged += async(_, e) => { if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating")) { this.EnableRating = (bool)e.SettingValue; this.SetTrackOrder("AlbumsTrackOrder"); await this.GetTracksAsync(null, null, this.SelectedAlbumIds, this.TrackOrder); } if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove")) { this.EnableLove = (bool)e.SettingValue; this.SetTrackOrder("AlbumsTrackOrder"); await this.GetTracksAsync(null, null, this.SelectedAlbumIds, this.TrackOrder); } }; // Events this.metadataService.MetadataChanged += MetadataChangedHandlerAsync; this.indexingService.AlbumArtworkAdded += async(_, e) => await this.RefreshArtworkAsync(e.AlbumIds); // Commands this.ToggleAlbumOrderCommand = new DelegateCommand(async() => await this.ToggleAlbumOrderAsync()); this.ToggleTrackOrderCommand = new DelegateCommand(async() => await this.ToggleTrackOrderAsync()); this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.RemoveTracksFromCollectionAsync(this.SelectedTracks), () => !this.IsIndexing); this.RemoveSelectedTracksFromDiskCommand = new DelegateCommand(async() => await this.RemoveTracksFromDiskAsync(this.SelectedTracks), () => !this.IsIndexing); // Set the initial AlbumOrder this.AlbumOrder = (AlbumOrder)SettingsClient.Get <int>("Ordering", "AlbumsAlbumOrder"); // Set the initial TrackOrder this.SetTrackOrder("AlbumsTrackOrder"); // Set width of the panels this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "AlbumsLeftPaneWidthPercent"); // Cover size this.SetCoversizeAsync((CoverSizeType)SettingsClient.Get <int>("CoverSizes", "AlbumsCoverSize")); }
protected override void InitializeShell(Window shell) { LogClient.Info($"### STARTING {ProductInformation.ApplicationName}, version {ProcessExecutable.AssemblyVersion()}, IsPortable = {SettingsClient.BaseGet<bool>("Configuration", "IsPortable")}, Windows version = {EnvironmentUtils.GetFriendlyWindowsVersion()} ({EnvironmentUtils.GetInternalWindowsVersion()}), IsWindows10 = {Core.Base.Constants.IsWindows10} ###"); // Handler for unhandled AppDomain exceptions AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; this.InitializeWcfServices(); Current.MainWindow = shell; bool showOobe = SettingsClient.Get <bool>("General", "ShowOobe"); if (showOobe) { var oobeWin = Container.Resolve <Oobe>(); // These 2 lines are required to set the RegionManager of the child window. // If we don't do this, regions on child windows are never known by the Shell // RegionManager and navigation doesn't work RegionManager.SetRegionManager(oobeWin, Container.Resolve <IRegionManager>()); RegionManager.UpdateRegions(); // Show the OOBE window. Don't tell the Indexer to start. // It will get a signal to start when the OOBE window closes. LogClient.Info("Showing Oobe screen"); // Disable shutdown when the dialogs close Application.Current.ShutdownMode = ShutdownMode.OnExplicitShutdown; // Show as a dialog. This prevents further code execution until the dialog is closed. oobeWin.ShowDialog(); oobeWin.ForceActivate(); } // Re-enable normal shutdown mode Current.ShutdownMode = ShutdownMode.OnMainWindowClose; // Show the main window LogClient.Info("Showing Main screen"); shell.Show(); // We're not showing the OOBE screen, tell the IndexingService to start. if (!showOobe) { Container.Resolve <IIndexingService>().RefreshCollectionAsync(); } }
public void CheckIfTabletMode(bool isInitializing) { if (this.windowsIntegrationService.IsTabletModeEnabled) { // Always revert to full player when tablet mode is enabled. Maximizing will be done by Windows. this.SetPlayer(false, (MiniPlayerType)SettingsClient.Get <int>("General", "MiniPlayerType"), isInitializing); } else { bool isMiniPlayer = SettingsClient.Get <bool>("General", "IsMiniPlayer"); bool isMaximized = SettingsClient.Get <bool>("FullPlayer", "IsMaximized"); this.WindowStateChangeRequested(this, new WindowStateChangeRequestedEventArgs(isMaximized & !isMiniPlayer ? WindowState.Maximized : WindowState.Normal)); this.SetPlayer(isMiniPlayer, (MiniPlayerType)SettingsClient.Get <int>("General", "MiniPlayerType"), isInitializing); } }
public async Task <AudioDevice> GetSavedAudioDeviceAsync() { string savedAudioDeviceId = SettingsClient.Get <string>("Playback", "AudioDevice"); IList <AudioDevice> audioDevices = await this.GetAllAudioDevicesAsync(); AudioDevice savedDevice = audioDevices.Where(x => x.DeviceId.Equals(savedAudioDeviceId)).FirstOrDefault(); if (savedDevice == null) { LogClient.Warning($"Audio device with deviceId={savedAudioDeviceId} could not be found. Using default device instead."); savedDevice = this.CreateDefaultAudioDevice(); } return(savedDevice); }
private async void GetCheckBoxesAsync() { await Task.Run(() => { // Change the backing field, not the property. Otherwise the confirmation popup is shown when the screen is constructed. this.checkBoxWasapiExclusiveModeChecked = SettingsClient.Get <bool>("Playback", "WasapiExclusiveMode"); OnPropertyChanged(() => this.CheckBoxWasapiExclusiveModeChecked); this.CheckBoxShowNotificationWhenPlayingChecked = SettingsClient.Get <bool>("Behaviour", "ShowNotificationWhenPlaying"); this.CheckBoxShowNotificationWhenPausingChecked = SettingsClient.Get <bool>("Behaviour", "ShowNotificationWhenPausing"); this.CheckBoxShowNotificationWhenResumingChecked = SettingsClient.Get <bool>("Behaviour", "ShowNotificationWhenResuming"); this.CheckBoxShowNotificationControlsChecked = SettingsClient.Get <bool>("Behaviour", "ShowNotificationControls"); this.CheckBoxShowProgressInTaskbarChecked = SettingsClient.Get <bool>("Playback", "ShowProgressInTaskbar"); this.CheckBoxShowNotificationOnlyWhenPlayerNotVisibleChecked = SettingsClient.Get <bool>("Behaviour", "ShowNotificationOnlyWhenPlayerNotVisible"); }); }
private async void GetCheckBoxesAsync() { await Task.Run(() => { this.checkBoxDownloadArtistInformationChecked = SettingsClient.Get <bool>("Lastfm", "DownloadArtistInformation"); this.checkBoxDownloadLyricsChecked = SettingsClient.Get <bool>("Lyrics", "DownloadLyrics"); string lyricsProviders = SettingsClient.Get <string>("Lyrics", "Providers"); this.checkBoxChartLyricsChecked = lyricsProviders.ToLower().Contains("chartlyrics"); this.checkBoxLoloLyricsChecked = lyricsProviders.ToLower().Contains("lololyrics"); this.checkBoxMetroLyricsChecked = lyricsProviders.ToLower().Contains("metrolyrics"); this.checkBoxXiamiLyricsChecked = lyricsProviders.ToLower().Contains("xiamilyrics"); this.checkBoxNeteaseLyricsChecked = lyricsProviders.ToLower().Contains("neteaselyrics"); }); }
private void CheckIfTabletMode() { if (this.windowsIntegrationService.IsTabletModeEnabled) { // Always revert to full player when tablet mode is enabled. Maximizing will be done by Windows. this.SetPlayer(false, (MiniPlayerType)SettingsClient.Get <int>("General", "MiniPlayerType")); } else { bool isMiniPlayer = SettingsClient.Get <bool>("General", "IsMiniPlayer"); bool isMaximized = SettingsClient.Get <bool>("FullPlayer", "IsMaximized"); this.WindowState = isMaximized & !isMiniPlayer ? WindowState.Maximized : WindowState.Normal; this.SetPlayer(isMiniPlayer, (MiniPlayerType)SettingsClient.Get <int>("General", "MiniPlayerType")); } }
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 Initialize() { // Commands this.ShowSelectedTrackInformationCommand = new DelegateCommand(() => this.ShowSelectedTrackInformation()); this.SelectedTracksCommand = new DelegateCommand <object>((parameter) => this.SelectedTracksHandler(parameter)); this.EditTracksCommand = new DelegateCommand(() => this.EditSelectedTracks(), () => !this.IsIndexing); this.LoadedCommand = new DelegateCommand(async() => await this.LoadedCommandAsync()); this.ShuffleAllCommand = new DelegateCommand(() => this.playbackService.ShuffleAllAsync()); // Events this.playbackService.PlaybackFailed += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackPaused += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackResumed += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackStopped += (_, __) => this.ShowPlayingTrackAsync(); this.playbackService.PlaybackSuccess += (_) => this.ShowPlayingTrackAsync(); this.collectionService.CollectionChanged += async(_, __) => await this.FillListsAsync(); // Refreshes the lists when the Collection has changed this.playlistService.PlaylistAdded += (_) => this.GetContextMenuPlaylistsAsync(); this.playlistService.PlaylistsDeleted += (_) => this.GetContextMenuPlaylistsAsync(); this.indexingService.RefreshLists += async(_, __) => await this.FillListsAsync(); // Refreshes the lists when the indexer has finished indexing this.indexingService.IndexingStarted += (_, __) => this.SetEditCommands(); this.indexingService.IndexingStopped += (_, __) => this.SetEditCommands(); this.searchService.DoSearch += (searchText) => { if (this.IsActive) { this.FilterLists(); } }; this.metadataService.RatingChanged += MetadataService_RatingChangedAsync; this.metadataService.LoveChanged += MetadataService_LoveChangedAsync; // Flags this.EnableRating = SettingsClient.Get <bool>("Behaviour", "EnableRating"); this.EnableLove = SettingsClient.Get <bool>("Behaviour", "EnableLove"); // This makes sure the IsIndexing is correct even when this ViewModel is // created after the Indexer is started, and thus after triggering the // IndexingService.IndexerStarted event. this.SetEditCommands(); // Initialize the playlists in the ContextMenu this.GetContextMenuPlaylistsAsync(); }
public CollectionAlbumsViewModel(IUnityContainer container) : base(container) { // Dependency injection this.indexingService = container.Resolve <IIndexingService>(); this.collectionService = container.Resolve <ICollectionService>(); this.metadataService = container.Resolve <IMetadataService>(); this.eventAggregator = container.Resolve <IEventAggregator>(); // Events this.metadataService.MetadataChanged += MetadataChangedHandlerAsync; this.indexingService.RefreshArtwork += async(_, __) => await this.collectionService.RefreshArtworkAsync(this.Albums); this.eventAggregator.GetEvent <SettingEnableRatingChanged>().Subscribe(async(enableRating) => { this.EnableRating = enableRating; this.SetTrackOrder("AlbumsTrackOrder"); await this.GetTracksAsync(null, null, this.SelectedAlbums, this.TrackOrder); }); this.eventAggregator.GetEvent <SettingEnableLoveChanged>().Subscribe(async(enableLove) => { this.EnableLove = enableLove; this.SetTrackOrder("AlbumsTrackOrder"); await this.GetTracksAsync(null, null, this.SelectedAlbums, this.TrackOrder); }); // Commands this.ToggleAlbumOrderCommand = new DelegateCommand(async() => await this.ToggleAlbumOrderAsync()); this.ToggleTrackOrderCommand = new DelegateCommand(async() => await this.ToggleTrackOrderAsync()); this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.RemoveTracksFromCollectionAsync(this.SelectedTracks), () => !this.IsIndexing); this.RemoveSelectedTracksFromDiskCommand = new DelegateCommand(async() => await this.RemoveTracksFromDiskAsync(this.SelectedTracks), () => !this.IsIndexing); // Set the initial AlbumOrder this.AlbumOrder = (AlbumOrder)SettingsClient.Get <int>("Ordering", "AlbumsAlbumOrder"); // Set the initial TrackOrder this.SetTrackOrder("AlbumsTrackOrder"); // Subscribe to Events and Commands on creation this.Subscribe(); // Set width of the panels this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "AlbumsLeftPaneWidthPercent"); // Cover size this.SetCoversizeAsync((CoverSizeType)SettingsClient.Get <int>("CoverSizes", "AlbumsCoverSize")); }
public NowPlayingScreenViewModel(IRegionManager regionManager, IPlaybackService playbackService) { this.regionManager = regionManager; this.playbackService = playbackService; if (SettingsClient.Get <bool>("Startup", "ShowLastSelectedPage")) { SelectedNowPlayingPage page = (SelectedNowPlayingPage)SettingsClient.Get <int>("FullPlayer", "SelectedNowPlayingPage"); switch (page) { case SelectedNowPlayingPage.ShowCase: this.isShowCaseVisible = true; break; case SelectedNowPlayingPage.Playlist: this.isPlaylistVisible = true; break; case SelectedNowPlayingPage.Lyrics: this.isLyricsVisible = true; break; case SelectedNowPlayingPage.ArtistInformation: this.isArtistInformationVisible = true; break; } } else { this.isPlaylistVisible = true; } this.playbackService.PlaybackSuccess += (_) => this.SetNowPlaying(); this.NowPlayingScreenShowcaseButtonCommand = new DelegateCommand(() => this.SetShowCase()); this.NowPlayingScreenPlaylistButtonCommand = new DelegateCommand(() => this.SetPlaylist()); this.NowPlayingScreenLyricsButtonCommand = new DelegateCommand(() => this.SetLyrics()); this.NowPlayingScreenArtistInformationButtonCommand = new DelegateCommand(() => this.SetArtistInformation()); this.LoadedCommand = new DelegateCommand(() => this.SetNowPlaying()); ApplicationCommands.NowPlayingScreenShowcaseButtonCommand.RegisterCommand(this.NowPlayingScreenShowcaseButtonCommand); ApplicationCommands.NowPlayingScreenPlaylistButtonCommand.RegisterCommand(this.NowPlayingScreenPlaylistButtonCommand); ApplicationCommands.NowPlayingScreenLyricsButtonCommand.RegisterCommand(this.NowPlayingScreenLyricsButtonCommand); ApplicationCommands.NowPlayingScreenArtistInformationButtonCommand.RegisterCommand(this.NowPlayingScreenArtistInformationButtonCommand); }
private void Shell_Restored(object sender, EventArgs e) { // This workaround is needed because when executing the following // sequence, the window is restored to the Restore Position of // the Mini Player: Maximize, Mini Player, Full Player, Restore. // That's because the property RestoreBounds of this window is updated // with the coordinates of the Mini Player when switching to the Mini // Player. Returning to the full player doesn't update RestoreBounds, // because the full player is still maximized at that point. this.SetGeometry( SettingsClient.Get <int>("FullPlayer", "Top"), SettingsClient.Get <int>("FullPlayer", "Left"), SettingsClient.Get <int>("FullPlayer", "Width"), SettingsClient.Get <int>("FullPlayer", "Height"), Constants.DefaultShellTop, Constants.DefaultShellLeft); }
public async Task ShowNotificationAsync() { if (this.notification != null) { this.notification.DoubleClicked -= ShowMainWindow; } try { if (this.notification != null) { this.notification.Disable(); } } catch (Exception ex) { LogClient.Error("Error while trying to disable the notification. Exception: {0}", ex.Message); } try { byte[] artworkData = null; if (this.playbackService.HasCurrentTrack) { artworkData = await this.metadataService.GetArtworkAsync(this.playbackService.CurrentTrack.Value.Path); } Application.Current.Dispatcher.Invoke(() => { this.notification = new NotificationWindow(this.playbackService.CurrentTrack.Value, artworkData, (NotificationPosition)SettingsClient.Get <int>("Behaviour", "NotificationPosition"), SettingsClient.Get <bool>("Behaviour", "ShowNotificationControls"), SettingsClient.Get <int>("Behaviour", "NotificationAutoCloseSeconds")); this.notification.DoubleClicked += ShowMainWindow; this.notification.Show(); }); } catch (Exception ex) { LogClient.Error("Error while trying to show the notification. Exception: {0}", ex.Message); } }
public void RefreshNotes() { this.Notes = new ObservableCollection <NoteViewModel>(); string formatDate = "D"; string text = ""; if (this.searchService.SearchText != null) { text = this.searchService.SearchText.Trim(); } // Make sure there is a notebook selected if (this.SelectedNotebook == null) { this.SetDefaultSelectedNotebook(); } this.Notes.Clear(); foreach (Note note in this.noteService.GetNotes(new Notebook { Id = SelectedNotebook.Id, Title = SelectedNotebook.Title, CreationDate = SelectedNotebook.CreationDate.Ticks }, text, ref this.total, SettingsClient.Get <bool>("Appearance", "SortByModificationDate"), this.NoteFilter)) { this.Notes.Add(new NoteViewModel { Title = note.Title, Id = note.Id, NotebookId = note.NotebookId, OpenDate = new DateTime(note.OpenDate), OpenDateText = DateUtils.DateDifference(new DateTime(note.OpenDate), DateTime.Now, formatDate, false), ModificationDate = new DateTime(note.ModificationDate), Flagged = note.Flagged == 1 ? true : false, ModificationDateText = DateUtils.DateDifference(new DateTime(note.ModificationDate), DateTime.Now, formatDate, false), ModificationDateTextSimple = DateUtils.DateDifference(new DateTime(note.ModificationDate), DateTime.Now, formatDate, true) }); } // Because we cannot pass Property "Total" by reference, we need to force a refresh. OnPropertyChanged <int>(() => this.Total); this.eventAggregator.GetEvent <CountNotesEvent>().Publish(""); }
private async void AddArtworkInBackgroundAsync() { // First, add artwork from file. await this.AddArtworkInBackgroundAsync(1); // Next, add artwork from the Internet, if the user has chosen to do so. if (SettingsClient.Get <bool>("Covers", "DownloadMissingAlbumCovers")) { // Add artwork from the Internet. await this.AddArtworkInBackgroundAsync(2); } else { // Don't add artwork from the Internet. Mark all albums as indexed. await this.MarkAllAlbumsAsIndexed(); } }
private void SetFullPlayer() { this.isMiniPlayerActive = false; this.PlaylistVisibilityChanged(this, new PlaylistVisibilityChangedEventArgs() { IsPlaylistVisible = false }); this.ResizeModeChanged(this, new ResizeModeChangedEventArgs() { ResizeMode = ResizeMode.CanResize }); this.ShowWindowControlsChanged(this, new ShowWindowControlsChangedEventArgs() { ShowWindowControls = true }); if (SettingsClient.Get <bool>("FullPlayer", "IsMaximized")) { this.WindowStateChanged(this, new WindowStateChangedEventArgs() { WindowState = WindowState.Maximized }); } else { this.WindowStateChanged(this, new WindowStateChangedEventArgs() { WindowState = WindowState.Normal }); this.GeometryChanged(this, new GeometryChangedEventArgs() { Top = SettingsClient.Get <int>("FullPlayer", "Top"), Left = SettingsClient.Get <int>("FullPlayer", "Left"), Size = new Size(SettingsClient.Get <int>("FullPlayer", "Width"), SettingsClient.Get <int>("FullPlayer", "Height")) }); } // Set MinWidth and MinHeight AFTER SetGeometry(). This prevents flicker. this.MinimumSizeChanged(this, new MinimumSizeChangedEventArgs() { MinimumSize = new Size(0, 0) }); }
private void SetWindowPositionLockedFromSettings() { // Only lock position when the mini player is active if (this.isMiniPlayerActive) { this.IsMovableChanged(this, new IsMovableChangedEventArgs() { IsMovable = !SettingsClient.Get <bool>("Behaviour", "MiniPlayerPositionLocked") }); } else { this.IsMovableChanged(this, new IsMovableChangedEventArgs() { IsMovable = true }); } }