public CollectionTracksViewModel(IContainerProvider container) : base(container)
{
// Dependency injection
this.container = container;
this.dialogService = container.Resolve <IDialogService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
// Settings
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating"))
{
this.EnableRating = (bool)e.Entry.Value;
this.GetVisibleColumns();
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove"))
{
this.EnableLove = (bool)e.Entry.Value;
this.GetVisibleColumns();
}
};
// Commands
this.ChooseColumnsCommand = new DelegateCommand(this.ChooseColumns);
this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.RemoveTracksFromCollectionAsync(this.SelectedTracks), () => !this.IsIndexing);
// Show only the columns which are visible
this.GetVisibleColumns();
}
public WindowsIntegrationService(IPlaybackService playbackService)
{
this.playbackService = playbackService;
this.isStartedFromExplorer = Environment.GetCommandLineArgs().Length > 1;
if (SettingsClient.Get <bool>("Playback", "PreventSleepWhilePlaying"))
{
this.EnableSleepPrevention();
}
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Playback", "PreventSleepWhilePlaying"))
{
bool preventSleepWhilePlaying = (bool)e.Entry.Value;
if (preventSleepWhilePlaying)
{
this.EnableSleepPrevention();
}
else
{
this.DisableSleepPrevention();
}
}
};
}
public RichPresenceService(IPlaybackService playbackService)
{
this.playbackService = playbackService;
if (SettingsClient.Get <bool>("Discord", "EnableDiscordRichPresence"))
{
this.RegisterClient();
}
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Discord", "EnableDiscordRichPresence"))
{
bool enableDiscordRichPresence = (bool)e.Entry.Value;
if (enableDiscordRichPresence)
{
this.RegisterClient();
this.ShowTrackDetails();
}
else
{
this.UnregisterClient();
}
}
};
}
public CollectionPlaylistsViewModel(IContainerProvider container, IDialogService dialogService,
IPlaybackService playbackService, IPlaylistService playlistService, IMetadataService metadataService,
IFileService fileService, IEventAggregator eventAggregator) : base(container)
{
this.dialogService = dialogService;
this.playlistService = playlistService;
this.playbackService = playbackService;
this.fileService = fileService;
this.eventAggregator = eventAggregator;
this.dialogService = dialogService;
this.metadataService = metadataService;
this.container = container;
// Events
this.playlistService.PlaylistFolderChanged += PlaylistService_PlaylistFolderChanged;
this.playlistService.TracksAdded += PlaylistService_TracksAdded;
this.playlistService.TracksDeleted += PlaylistService_TracksDeleted;
this.metadataService.LoveChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync();
this.metadataService.RatingChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync();
this.metadataService.MetadataChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync();
this.playbackService.PlaybackCountersChanged += async(_) => await this.GetTracksIfSmartPlaylistSelectedAsync();
// Commands
this.EditSelectedPlaylistCommand = new DelegateCommand(async() => await this.EditSelectedPlaylistAsync());
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.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.Entry.Value;
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove"))
{
this.EnableLove = (bool)e.Entry.Value;
}
};
// Load settings
this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "PlaylistsLeftPaneWidthPercent");
}
private void InitializeShellWindow()
{
// Start monitoring tablet mode
this.windowsIntegrationService.StartMonitoringTabletMode();
// Tray controls
this.trayControls = this.container.Resolve <TrayControls>();
// Create the Mini Player playlist
this.miniPlayerPlaylist = this.container.Resolve <MiniPlayerPlaylist>(new DependencyOverride(typeof(DopamineWindow), this));
// NotificationService needs to know about the application windows
this.notificationService.SetApplicationWindows(this, this.miniPlayerPlaylist, this.trayControls);
// Settings changed
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowWindowBorder"))
{
this.SetWindowBorder((bool)e.SettingValue);
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "ShowTrayIcon"))
{
this.trayIcon.Visible = (bool)e.SettingValue;
}
};
// Make sure the window geometry respects tablet mode at startup
this.CheckIfTabletMode();
}
public MiniPlayerPlaylist(Windows10BorderlessWindow parent, IPlaybackService playbackService, IRegionManager regionManager, IEventAggregator eventAggregator)
{
InitializeComponent();
this.parent = parent;
this.playbackService = playbackService;
this.regionManager = regionManager;
this.eventAggregator = eventAggregator;
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowWindowBorder"))
{
this.WindowBorder.BorderThickness = new Thickness((bool)e.Entry.Value ? 1 : 0);
}
};
this.eventAggregator.GetEvent <ToggledCoverPlayerAlignPlaylistVertically>().Subscribe(async alignPlaylistVertically =>
{
this.alignCoverPlayerPlaylistVertically = alignPlaylistVertically;
if (this.IsVisible)
{
await this.SetGeometry();
}
});
}
public LyricsControlViewModel(IUnityContainer container) : base(container)
{
this.container = container;
this.info = container.Resolve <ILocalizationInfo>();
this.metadataService = container.Resolve <IMetadataService>();
this.playbackService = container.Resolve <IPlaybackService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
this.highlightTimer.Interval = this.highlightTimerIntervalMilliseconds;
this.highlightTimer.Elapsed += HighlightTimer_Elapsed;
this.updateLyricsAfterEditingTimer.Interval = this.updateLyricsAfterEditingTimerIntervalMilliseconds;
this.updateLyricsAfterEditingTimer.Elapsed += UpdateLyricsAfterEditingTimer_Elapsed;
this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds;
this.refreshTimer.Elapsed += RefreshTimer_Elapsed;
this.playbackService.PlaybackPaused += (_, __) => this.highlightTimer.Stop();
this.playbackService.PlaybackResumed += (_, __) => this.highlightTimer.Start();
this.metadataService.MetadataChanged += (_) => this.RestartRefreshTimer();
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Lyrics", "DownloadLyrics"))
{
if ((bool)e.SettingValue)
{
this.RestartRefreshTimer();
}
}
};
this.isNowPlayingPageActive = SettingsClient.Get <bool>("FullPlayer", "IsNowPlayingSelected");
this.isNowPlayingLyricsPageActive = ((NowPlayingSubPage)SettingsClient.Get <int>("FullPlayer", "SelectedNowPlayingSubPage")) == NowPlayingSubPage.Lyrics;
this.eventAggregator.GetEvent <IsNowPlayingPageActiveChanged>().Subscribe(isNowPlayingPageActive =>
{
this.isNowPlayingPageActive = isNowPlayingPageActive;
this.RestartRefreshTimer();
});
this.eventAggregator.GetEvent <IsNowPlayingSubPageChanged>().Subscribe(tuple =>
{
this.isNowPlayingLyricsPageActive = tuple.Item2 == NowPlayingSubPage.Lyrics;
this.RestartRefreshTimer();
});
this.RefreshLyricsCommand = new DelegateCommand(() => this.RestartRefreshTimer(), () => !this.IsDownloadingLyrics);
ApplicationCommands.RefreshLyricsCommand.RegisterCommand(this.RefreshLyricsCommand);
this.playbackService.PlaybackSuccess += (_, e) =>
{
this.ContentSlideInFrom = e.IsPlayingPreviousTrack ? -30 : 30;
this.RestartRefreshTimer();
};
this.ClearLyrics(); // Makes sure the loading animation can be shown even at first start
}
private void InitializeWindows()
{
// Start monitoring tablet mode
this.windowsIntegrationService.StartMonitoringTabletMode();
// Tray controls
this.trayControls = this.container.Resolve <TrayControls>();
// Create the Mini Player playlist
this.miniPlayerPlaylist = this.container.Resolve <Func <BorderlessWindows10Window, MiniPlayerPlaylist> >()(this);
// NotificationService needs to know about the application windows
this.notificationService.SetApplicationWindows(this, this.miniPlayerPlaylist, this.trayControls);
// Settings changed
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowWindowBorder"))
{
this.WindowBorder.BorderThickness = new Thickness((bool)e.SettingValue ? 1 : 0);
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "ShowTrayIcon"))
{
this.trayIcon.Visible = (bool)e.SettingValue;
}
};
this.shellService.WindowStateChangeRequested += (_, e) => this.WindowState = e.WindowState;
this.shellService.IsMovableChangeRequested += (_, e) => this.IsMovable = e.IsMovable;
this.shellService.ResizeModeChangeRequested += (_, e) => this.ResizeMode = e.ResizeMode;
this.shellService.TopmostChangeRequested += (_, e) => this.Topmost = e.IsTopmost;
this.shellService.GeometryChangeRequested += (_, e) => this.SetGeometry(
e.Top, e.Left, e.Size.Width, e.Size.Height,
Constants.DefaultShellTop,
Constants.DefaultShellLeft);
this.shellService.MinimumSizeChangeRequested += (_, e) =>
{
this.MinWidth = e.MinimumSize.Width;
this.MinHeight = e.MinimumSize.Height;
};
this.shellService.PlaylistVisibilityChangeRequested += (_, e) =>
{
if (e.IsPlaylistVisible)
{
this.miniPlayerPlaylist.Show(e.MiniPlayerType);
}
else
{
this.miniPlayerPlaylist.Hide();
}
};
this.shellService.CheckIfTabletMode(true); // Make sure the window geometry respects tablet mode at startup
this.SetWindowBorder();
}
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.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));
}
if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowTrackArtOnPlaylists"))
{
this.ShowTrackArt = (bool)e.SettingValue;
this.UpdateShowTrackArtAsync();
}
};
// Events
this.i18nService.LanguageChanged += (_, __) =>
{
RaisePropertyChanged(nameof(this.TotalDurationInformation));
RaisePropertyChanged(nameof(this.TotalSizeInformation));
this.RefreshLanguage();
};
this.playbackService.PlaybackCountersChanged += PlaybackService_PlaybackCountersChanged;
// Load settings
this.ShowTrackArt = SettingsClient.Get <bool>("Appearance", "ShowTrackArtOnPlaylists");
}
public PlaybackInfoControlViewModel(IPlaybackService playbackService, IMetadataService metadataService, IScrobblingService scrobblingService)
{
this.playbackService = playbackService;
this.metadataService = metadataService;
this.scrobblingService = scrobblingService;
this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds;
this.refreshTimer.Elapsed += RefreshTimer_Elapsed;
this.playbackService.PlaybackSuccess += (_, e) =>
{
this.SlideDirection = e.IsPlayingPreviousTrack ? SlideDirection.UpToDown : SlideDirection.DownToUp;
this.refreshTimer.Stop();
this.refreshTimer.Start();
};
this.playbackService.PlaybackProgressChanged += (_, __) => this.UpdateTime();
this.playbackService.PlayingTrackChanged += (_, __) => this.RefreshPlaybackInfoAsync(this.playbackService.CurrentTrack, true);
this.metadataService.RatingChanged += (e) =>
{
if (this.track != null && e.SafePath.Equals(this.track.SafePath))
{
this.track.Rating = e.Rating;
this.RaisePropertyChanged(nameof(Rating));
}
};
this.metadataService.LoveChanged += (e) =>
{
if (this.track != null && e.SafePath.Equals(this.track.SafePath))
{
this.track.Love = e.Love;
this.RaisePropertyChanged(nameof(Love));
}
};
// Settings
SettingsClient.SettingChanged += async(_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating"))
{
this.EnableRating = (bool)e.SettingValue;
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove"))
{
this.EnableLove = (bool)e.SettingValue;
}
};
// Defaults
this.SlideDirection = SlideDirection.DownToUp;
this.RefreshPlaybackInfoAsync(this.playbackService.CurrentTrack, false);
this.EnableRating = SettingsClient.Get <bool>("Behaviour", "EnableRating");
this.EnableLove = SettingsClient.Get <bool>("Behaviour", "EnableLove");
}
public CollectionPlaylistsViewModel(IContainerProvider container) : base(container)
{
// Dependency injection
this.fileService = container.Resolve <IFileService>();
this.playlistService = container.Resolve <IPlaylistService>();
this.playbackService = container.Resolve <IPlaybackService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
this.dialogService = container.Resolve <IDialogService>();
// Commands
this.LoadedCommand = new DelegateCommand(async() => await this.LoadedCommandAsync());
this.NewPlaylistCommand = new DelegateCommand(async() => await this.ConfirmAddPlaylistAsync());
this.OpenPlaylistCommand = new DelegateCommand(async() => await this.OpenPlaylistAsync());
this.RenameSelectedPlaylistCommand = new DelegateCommand(async() => await this.RenameSelectedPlaylistAsync());
this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.DeleteTracksFromPlaylistsAsync());
this.AddPlaylistToNowPlayingCommand = new DelegateCommand(async() => await this.AddPlaylistToNowPlayingAsync());
this.DeletePlaylistByNameCommand = new DelegateCommand <string>(async(playlistName) => await this.ConfirmDeletePlaylistAsync(playlistName));
this.ShuffleSelectedPlaylistCommand = new DelegateCommand(async() => await this.ShuffleSelectedPlaylistAsync());
this.DeleteSelectedPlaylistCommand = new DelegateCommand(async() =>
{
if (this.IsPlaylistSelected)
{
await this.ConfirmDeletePlaylistAsync(this.SelectedPlaylistName);
}
});
// 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;
}
};
// Events
this.playlistService.TracksAdded += async(numberTracksAdded, playlistName) => await this.UpdateAddedTracksAsync(playlistName);
this.playlistService.TracksDeleted += async(playlistName) => await this.UpdateDeletedTracksAsync(playlistName);
this.playlistService.PlaylistAdded += (addedPlaylistName) => this.UpdateAddedPlaylist(addedPlaylistName);
this.playlistService.PlaylistDeleted += (deletedPlaylistName) => this.UpdateDeletedPlaylist(deletedPlaylistName);
this.playlistService.PlaylistRenamed += (oldPlaylistName, newPlaylistName) => this.UpdateRenamedPlaylist(oldPlaylistName, newPlaylistName);
this.playlistService.PlaylistFolderChanged += async(_, __) => await this.FillListsAsync();
// Load settings
this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "PlaylistsLeftPaneWidthPercent");
}
public Win32InputService(IPlaybackService playbackService)
{
this.playbackService = playbackService;
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "MediaKeys", "UseAppCommandMediaKeys"))
{
this.SetEventHandlers();
}
};
}
private async void SettingsClient_SettingChanged(object sender, SettingChangedEventArgs e)
{
if (SettingsClient.IsSettingChanged(e, "Indexing", "RefreshCollectionAutomatically"))
{
if ((bool)e.SettingValue)
{
await this.watcherManager.StartWatchingAsync();
}
else
{
await this.watcherManager.StopWatchingAsync();
}
}
}
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 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"));
}
public Win32InputService(IPlaybackService playbackService)
{
this.playbackService = playbackService;
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "MediaKeys", "UseAppCommandMediaKeys"))
{
this.SetEventHandlers();
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableSystemNotification"))
{
this.SetEventHandlers();
}
};
}
public LyricsControlViewModel(IUnityContainer container) : base(container)
{
this.container = container;
this.info = container.Resolve <ILocalizationInfo>();
this.metadataService = container.Resolve <IMetadataService>();
this.playbackService = container.Resolve <IPlaybackService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
this.highlightTimer.Interval = this.highlightTimerIntervalMilliseconds;
this.highlightTimer.Elapsed += HighlightTimer_Elapsed;
this.updateLyricsAfterEditingTimer.Interval = this.updateLyricsAfterEditingTimerIntervalMilliseconds;
this.updateLyricsAfterEditingTimer.Elapsed += UpdateLyricsAfterEditingTimer_Elapsed;
this.refreshTimer.Interval = this.refreshTimerIntervalMilliseconds;
this.refreshTimer.Elapsed += RefreshTimer_Elapsed;
this.playbackService.PlaybackPaused += (_, __) => this.highlightTimer.Stop();
this.playbackService.PlaybackResumed += (_, __) => this.highlightTimer.Start();
this.metadataService.MetadataChanged += (_) => this.RestartRefreshTimer();
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Lyrics", "DownloadLyrics"))
{
if ((bool)e.SettingValue)
{
this.RestartRefreshTimer();
}
}
};
this.RefreshLyricsCommand = new DelegateCommand(() => this.RestartRefreshTimer(), () => !this.IsDownloadingLyrics);
ApplicationCommands.RefreshLyricsCommand.RegisterCommand(this.RefreshLyricsCommand);
this.playbackService.PlaybackSuccess += (isPlayingPreviousTrack) =>
{
this.ContentSlideInFrom = isPlayingPreviousTrack ? -30 : 30;
this.RestartRefreshTimer();
};
this.ClearLyrics(); // Makes sure the loading animation can be shown even at first start
}
public SpectrumAnalyzerControlViewModel(IPlaybackService playbackService, IAppearanceService appearanceService, IEventAggregator eventAggregator)
{
this.playbackService = playbackService;
this.eventAggregator = eventAggregator;
this.appearanceService = appearanceService;
this.playbackService.SpectrumVisibilityChanged += isSpectrumVisible => this.ShowSpectrumAnalyzer = isSpectrumVisible;
this.appearanceService.ColorSchemeChanged += (_, __) =>
Application.Current.Dispatcher.Invoke(() => this.SetSpectrumStyle((SpectrumStyle)SettingsClient.Get <int>("Playback", "SpectrumStyle")));
this.playbackService.PlaybackFailed += (_, __) => this.IsPlaying = false;
this.playbackService.PlaybackStopped += (_, __) => this.IsPlaying = false;
this.playbackService.PlaybackPaused += (_, __) => this.IsPlaying = false;
this.playbackService.PlaybackResumed += (_, __) => this.IsPlaying = true;
this.playbackService.PlaybackSuccess += (_, __) => this.IsPlaying = true;
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Playback", "SpectrumStyle"))
{
this.SetSpectrumStyle((SpectrumStyle)e.SettingValue);
}
};
// Spectrum analyzer performance is only acceptable with Windows Media Foundation
this.ShowSpectrumAnalyzer = this.playbackService.SupportsWindowsMediaFoundation &&
SettingsClient.Get <bool>("Playback", "ShowSpectrumAnalyzer");
// Initial value
if (!this.playbackService.IsStopped & this.playbackService.IsPlaying)
{
this.IsPlaying = true;
}
else
{
this.IsPlaying = false;
}
// Default spectrum
this.SetSpectrumStyle((SpectrumStyle)SettingsClient.Get <int>("Playback", "SpectrumStyle"));
}
public PlaylistsViewModelBase(IContainerProvider container, IDialogService dialogService,
IPlaybackService playbackService, IPlaylistServiceBase playlistServiceBase) : base(container)
{
this.dialogService = dialogService;
this.playlistServiceBase = playlistServiceBase;
this.playbackService = playbackService;
// Events
this.playlistServiceBase.PlaylistFolderChanged += PlaylistServiceBase_PlaylistFolderChanged;;
this.playlistServiceBase.PlaylistAdded += PlaylistServiceBase_PlaylistAdded;
this.playlistServiceBase.PlaylistDeleted += PlaylistServiceBase_PlaylistDeleted;
this.playlistServiceBase.PlaylistRenamed += PlaylistServiceBase_PlaylistRenamed;
// 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.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;
}
};
}
public SpectrumAnalyzerControl()
{
InitializeComponent();
this.playbackService = ServiceLocator.Current.GetInstance <IPlaybackService>();
this.shellService = ServiceLocator.Current.GetInstance <IShellService>();
this.playbackService.PlaybackSuccess += (_, __) => this.TryRegisterSpectrumPlayers();
this.shellService.WindowStateChanged += (_, __) => this.TryRegisterSpectrumPlayers();
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Playback", "ShowSpectrumAnalyzer"))
{
this.TryRegisterSpectrumPlayers();
}
};
this.TryRegisterSpectrumPlayers();
}
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>();
// 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());
// Settings
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 SpectrumAnalyzerControlViewModel(IPlaybackService playbackService, IAppearanceService appearanceService, IEventAggregator eventAggregator)
{
this.playbackService = playbackService;
this.eventAggregator = eventAggregator;
this.appearanceService = appearanceService;
this.appearanceService.ColorSchemeChanged += (_, __) =>
Application.Current.Dispatcher.Invoke(() => this.SetSpectrumStyle((SpectrumStyle)SettingsClient.Get <int>("Playback", "SpectrumStyle")));
this.playbackService.PlaybackFailed += (_, __) => this.IsPlaying = false;
this.playbackService.PlaybackStopped += (_, __) => this.IsPlaying = false;
this.playbackService.PlaybackPaused += (_, __) => this.IsPlaying = false;
this.playbackService.PlaybackResumed += (_, __) => this.IsPlaying = true;
this.playbackService.PlaybackSuccess += (_, __) => this.IsPlaying = true;
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Playback", "SpectrumStyle"))
{
this.SetSpectrumStyle((SpectrumStyle)e.Entry.Value);
}
};
// Initial value
if (!this.playbackService.IsStopped & this.playbackService.IsPlaying)
{
this.IsPlaying = true;
}
else
{
this.IsPlaying = false;
}
// Default spectrum
this.SetSpectrumStyle((SpectrumStyle)SettingsClient.Get <int>("Playback", "SpectrumStyle"));
}
public CollectionGenresViewModel(IContainerProvider container) : base(container)
{
// Dependency injection
this.collectionService = container.Resolve <ICollectionService>();
this.dialogService = container.Resolve <IDialogService>();
this.indexingService = container.Resolve <IIndexingService>();
this.playbackService = container.Resolve <IPlaybackService>();
this.playlistService = container.Resolve <IPlaylistService>();
this.searchService = container.Resolve <ISearchService>();
this.eventAggregator = container.Resolve <IEventAggregator>();
// Commands
this.ToggleTrackOrderCommand = new DelegateCommand(async() => await this.ToggleTrackOrderAsync());
this.ToggleAlbumOrderCommand = new DelegateCommand(async() => await this.ToggleAlbumOrderAsync());
this.RemoveSelectedTracksCommand = new DelegateCommand(async() => await this.RemoveTracksFromCollectionAsync(this.SelectedTracks), () => !this.IsIndexing);
this.AddGenresToPlaylistCommand = new DelegateCommand <string>(async(playlistName) => await this.AddGenresToPlaylistAsync(this.SelectedGenres, playlistName));
this.SelectedGenresCommand = new DelegateCommand <object>(async(parameter) => await this.SelectedGenresHandlerAsync(parameter));
this.ShowGenresZoomCommand = new DelegateCommand(async() => await this.ShowSemanticZoomAsync());
this.AddGenresToNowPlayingCommand = new DelegateCommand(async() => await this.AddGenresToNowPlayingAsync(this.SelectedGenres));
this.ShuffleSelectedGenresCommand = new DelegateCommand(async() => await this.playbackService.EnqueueGenresAsync(this.SelectedGenres, true, false));
this.SemanticJumpCommand = new DelegateCommand <string>((header) =>
{
this.HideSemanticZoom();
this.eventAggregator.GetEvent <PerformSemanticJump>().Publish(new Tuple <string, string>("Genres", header));
});
// Settings
SettingsClient.SettingChanged += async(_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableRating"))
{
this.EnableRating = (bool)e.SettingValue;
this.SetTrackOrder("GenresTrackOrder");
await this.GetTracksAsync(null, this.SelectedGenres, this.SelectedAlbums, this.TrackOrder);
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "EnableLove"))
{
this.EnableLove = (bool)e.SettingValue;
this.SetTrackOrder("GenresTrackOrder");
await this.GetTracksAsync(null, this.SelectedGenres, this.SelectedAlbums, this.TrackOrder);
}
};
// PubSub Events
this.eventAggregator.GetEvent <ShellMouseUp>().Subscribe((_) => this.IsGenresZoomVisible = false);
// Set the initial AlbumOrder
this.AlbumOrder = (AlbumOrder)SettingsClient.Get <int>("Ordering", "GenresAlbumOrder");
// Set the initial TrackOrder
this.SetTrackOrder("GenresTrackOrder");
// Set width of the panels
this.LeftPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "GenresLeftPaneWidthPercent");
this.RightPaneWidthPercent = SettingsClient.Get <int>("ColumnWidths", "GenresRightPaneWidthPercent");
// Cover size
this.SetCoversizeAsync((CoverSizeType)SettingsClient.Get <int>("CoverSizes", "GenresCoverSize"));
}
private void InitializeWindows()
{
// Start monitoring tablet mode
this.windowsIntegrationService.StartMonitoringTabletMode();
// Tray controls
this.trayControls = this.container.Resolve <TrayControls>();
// Create the Mini Player playlist
this.miniPlayerPlaylist = this.container.Resolve <MiniPlayerPlaylist>(new DependencyOverride(typeof(DopamineWindow), this));
// NotificationService needs to know about the application windows
this.notificationService.SetApplicationWindows(this, this.miniPlayerPlaylist, this.trayControls);
PART_MiniPlayerButton.ToolTip = SettingsClient.Get <bool>("General", "IsMiniPlayer") ? ResourceUtils.GetString("Language_Restore") : ResourceUtils.GetString("Language_Mini_Player");
// Settings changed
SettingsClient.SettingChanged += (_, e) =>
{
if (SettingsClient.IsSettingChanged(e, "Appearance", "ShowWindowBorder"))
{
this.WindowBorder.BorderThickness = new Thickness((bool)e.SettingValue ? 1 : 0);
}
if (SettingsClient.IsSettingChanged(e, "Behaviour", "ShowTrayIcon"))
{
this.trayIcon.Visible = (bool)e.SettingValue;
}
if (SettingsClient.IsSettingChanged(e, "General", "IsMiniPlayer"))
{
PART_MiniPlayerButton.ToolTip = (bool)e.SettingValue ? ResourceUtils.GetString("Language_Restore") : ResourceUtils.GetString("Language_Mini_Player");
}
};
this.shellService.WindowStateChanged += (_, e) => this.WindowState = e.WindowState;
this.shellService.IsMovableChanged += (_, e) => this.IsMovable = e.IsMovable;
this.shellService.ResizeModeChanged += (_, e) => this.ResizeMode = e.ResizeMode;
this.shellService.TopmostChanged += (_, e) => this.Topmost = e.IsTopmost;
this.shellService.ShowWindowControlsChanged += (_, e) => this.ShowWindowControls = e.ShowWindowControls;
this.shellService.GeometryChanged += (_, e) => this.SetGeometry(
e.Top, e.Left, e.Size.Width, e.Size.Height,
Constants.DefaultShellTop,
Constants.DefaultShellLeft);
this.shellService.MinimumSizeChanged += (_, e) =>
{
this.MinWidth = e.MinimumSize.Width;
this.MinHeight = e.MinimumSize.Height;
};
this.shellService.PlaylistVisibilityChanged += (_, e) =>
{
if (e.IsPlaylistVisible)
{
this.miniPlayerPlaylist.Show(e.MiniPlayerType);
}
else
{
this.miniPlayerPlaylist.Hide();
}
};
this.shellService.CheckIfTabletMode(true); // Make sure the window geometry respects tablet mode at startup
this.SetWindowBorder();
}
