/// <summary>
/// Loads and adds a track to the library
/// </summary>
/// <param name="filename">The filename of the track to add.
/// If the file is a playlist, all tracks in the playlist are added.
/// </param>
public void AddTracks(string path)
{
if (!File.Exists(path) && !Directory.Exists(path))
{
return;
}
if (Path.GetExtension(path).ToLower() == ".m3u")
{
foreach (var entry in PlaylistHelper.GetPlaylistEntries(path))
{
if (Path.GetExtension(entry.Path).ToLower() == ".mp3" &&
File.Exists(entry.Path))
{
AddTrack(_bassPlayer.LoadTrack(entry.Path, entry.Artist, entry.Title));
}
}
}
else if (Directory.Exists(path))
{
foreach (var file in Directory.GetFiles(path).ToList())
{
if (Path.GetExtension(file).ToLower() == ".mp3")
{
AddTracks(file);
}
}
}
else if (Path.GetExtension(path).ToLower() == ".mp3")
{
AddTrack(_bassPlayer.LoadTrack(path));
}
}
public override async void Execute(object parameter)
{
var trackCollection = Locator.MusicLibraryVM.CurrentTrackCollection;
if (trackCollection == null || trackCollection.Playlist == null || !trackCollection.Playlist.Any())
{
return;
}
if (parameter is int)
{
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(trackCollection.Playlist, true, (int)parameter);
}
else if (parameter is ItemClickEventArgs)
{
var track = (TrackItem)((ItemClickEventArgs)parameter).ClickedItem;
var index = trackCollection.Playlist.IndexOf(track);
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(trackCollection.Playlist, true, index);
}
else
{
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(trackCollection.Playlist);
}
Locator.NavigationService.GoBack_HideFlyout();
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
}
/// <summary>
/// Initializes a new instance of the PlaylistViewModel class.
/// </summary>
public PlaylistViewModel(INavigationService navigationService, IStorageService storageService)
{
_navigationService = navigationService;
_playlistChecker = new DispatcherTimer {
Interval = new TimeSpan(0, 0, 3)
};
_playlistChecker.Tick += PlaylistCheckerOnTick;
Playlist = new ObservableCollection <PlaylistItem>();
SelectedItems = new List <PlaylistItem>();
if (IsInDesignMode)
{
Playlist = new ObservableCollection <PlaylistItem>
{
new PlaylistItem {
Artist = "John Williams", Album = "Jurassic Park OST", Id = 1, IsPlaying = true, TrackName = "Jurassic Park Theme"
},
new PlaylistItem {
Artist = "John Williams", Album = "Jurassic Park OST", Id = 2, IsPlaying = false, TrackName = "Journey to the Island"
},
new PlaylistItem {
Artist = "John Williams", Album = "Jurassic Park OST", Id = 3, IsPlaying = false, TrackName = "Incident at Isla Nublar"
}
};
NowPlayingItem = Playlist[0];
}
else
{
_playlistHelper = new PlaylistHelper(storageService);
BackgroundAudioPlayer.Instance.PlayStateChanged += OnPlayStateChanged;
}
}
/// <summary>
/// Plays all songs from the given folder, starting with item defined by startPos
/// </summary>
/// <param name="folder">Folder that is played</param>
/// <param name="extensions">Valid extensions</param>
/// <param name="startPos">Position from where playback is started (playlist index)</param>
internal static void PlayAllFilesInFolder(string folder, string[] extensions, int startPos)
{
WifiRemote.LogMessage("Adding all files in " + folder + " to current playlist", WifiRemote.LogType.Debug);
if (Directory.Exists(folder))
{
PlaylistHelper.ClearPlaylist("music", false);
List <PlayListItem> items = new List <PlayListItem>();
foreach (String f in Directory.GetFiles(folder))
{
if (isValidExtension(f, extensions))
{
FileInfo fileInfo = new FileInfo(f);
items.Add(new PlayListItem(fileInfo.Name, fileInfo.FullName, 0));
}
}
PlaylistHelper.AddPlaylistItems(PlayListType.PLAYLIST_MUSIC, items, 0);
PlaylistHelper.StartPlayingPlaylist("music", startPos, true);
}
else
{
WifiRemote.LogMessage("Folder " + folder + " doesn't exist", WifiRemote.LogType.Warn);
}
}
/// <summary>
/// Navigates to the Audio Player screen with the requested file a parameter.
/// </summary>
/// <param name="file">The file to be played.</param>
public async Task PlayAudioFile(StorageFile file)
{
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
var trackItem = await MusicLibraryManagement.GetTrackItemFromFile(file);
await PlaylistHelper.PlayTrackFromFilePicker(trackItem);
}
public override async void Execute(object parameter)
{
var items = (ObservableCollection <IStorageItem>)parameter;
var files = new List <StorageFile>();
foreach (var item in items)
{
var file = item as StorageFile;
if (file != null && VLCFileExtensions.Supported.Contains(file.FileType.ToLower()))
{
files.Add((StorageFile)item);
}
}
var playlist = new ObservableCollection <IVLCMedia>();
foreach (var file in files)
{
if (VLCFileExtensions.AudioExtensions.Contains(file.FileType.ToLower()))
{
var trackItem = await MusicLibraryManagement.GetTrackItemFromFile(file);
playlist.Add(trackItem);
}
else if (VLCFileExtensions.VideoExtensions.Contains(file.FileType.ToLower()))
{
var videoVm = new VideoItem();
await videoVm.Initialize(file);
playlist.Add(videoVm);
}
}
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(playlist, true, 0);
}
public void DoWork(PlaylistHelper Helper)
{
if (Option != PlaylistOptions.None)
{
Helper.WritePlaylist(Option);
}
}
internal static void PlayFolder(String folder, string[] extensions, int startPos)
{
WifiRemote.LogMessage("Adding all files in " + folder + " to current playlist", WifiRemote.LogType.Debug);
if (Directory.Exists(folder))
{
PlaylistHelper.ClearPlaylist("video", false);
int index = 0;
foreach (String f in Directory.GetFiles(folder))
{
if (IsValidExtension(f, extensions))
{
PlaylistHelper.AddItemToPlaylist("video", f, index, false);
index++;
}
}
PlaylistHelper.RefreshPlaylistIfVisible();
PlaylistHelper.StartPlayingPlaylist("video", startPos, true);
}
else
{
WifiRemote.LogMessage("Folder " + folder + " doesn't exist", WifiRemote.LogType.Warn);
}
}
public override async void Execute(object parameter)
{
Locator.NavigationService.GoBack_HideFlyout();
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
if (parameter is AlbumItem)
{
var album = parameter as AlbumItem;
await PlaylistHelper.AddAlbumToPlaylist(album.Id, true, true, null, 0);
}
}
public override async void Execute(object parameter)
{
if (Locator.MusicLibraryVM.Tracks == null || !Locator.MusicLibraryVM.Tracks.Any())
{
return;
}
var shuffledTracks = Locator.MusicLibraryVM.Tracks.Shuffle();
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(shuffledTracks.ToPlaylist());
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
}
public override async void Execute(object parameter)
{
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
Locator.MusicLibraryVM.IsAlbumPageShown = false;
if (parameter is ArtistItem)
{
var artist = parameter as ArtistItem;
var tracks = await Locator.MusicLibraryVM._trackDatabase.LoadTracksByArtistId(artist.Id).ToObservableAsync();
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(tracks.ToPlaylist());
}
}
/// <summary>
/// Recursively scans for music files present in a directory but absent from the Rekordbox Library
/// </summary>
/// <param name="Dir">Directory root</param>
/// <returns></returns>
public List <string> Unreferenced(string Dir)
{
return((
from s in PlaylistHelper.MusicFiles(Dir)
where !(from t in Collection.Tracks
select
PlaylistHelper.LocationCleanUp(t.Location.ToUpper()))
.Contains(s.ToUpper())
orderby s
select s
).ToList());
}
/// <summary>
/// Navigates to the Video Player screen with the requested file a parameter.
/// </summary>
/// <param name="file">The file to be played.</param>
/// <param name="token">Token is for files that are NOT in the sandbox, such as files taken from the filepicker from a sd card but not in the Video/Music folder.</param>
public async Task PlayVideoFile(StorageFile file, string token = null)
{
Locator.NavigationService.Go(VLCPage.VideoPlayerPage);
VideoItem videoVm = new VideoItem();
await videoVm.Initialize(file);
if (token != null)
{
videoVm.Token = token;
}
Locator.VideoVm.CurrentVideo = videoVm;
await PlaylistHelper.Play(videoVm);
}
public void LoadPlayList(string playlist)
{
this.PlaylistFiles = PlaylistHelper.GetFilesInPlaylist(playlist);
this.Library.Clear();
this.Library.LoadFromPlaylist(playlist);
var existingFiles = this.Library.GetTracks().Select(t => t.Filename).ToList();
var missingFiles = this.PlaylistFiles.Except(existingFiles).ToList();
this.PlaylistFiles = this.PlaylistFiles.Except(missingFiles).ToList();
this.QueueNextTrack();
}
public void DetermineOrigin(KeyValuePair <int, KeyValuePair <PlaylistItem, string> > songDetails)
{
PlaylistHelper PH = new PlaylistHelper();
var basePair = PH.GetBasePair(songDetails);
PlaylistItem fileInfo = PH.GetFileInfo(songDetails);
var id = fileInfo.Id;
var origin = basePair.Value;
//switch??
//Switch on Origins
}
private void InitializeBinding()
{
tbxPlayerTitle.Text = PlayerTitle;
tbkMediaTitle.Text = InternalResources.PlaylistOpened;
cbxLoopingState.ItemsSource = PlaylistHelper.GetLoopingStates().Select(pair => pair.Key);
cbxLoopingState.SelectedIndex = 0;
tbkCurrentTime.Text = TimeSpanEmpty;
tbkDurationTime.Text = TimeSpanEmpty;
tbxSinglePlayDurationTime.Text = TimeSpanEmpty;
tbxSinglePlayIntervalTime.Text = TimeSpanEmpty;
tbxTotalPlayDurationTime.Text = TimeSpanEmpty;
}
private void btnSave_Click(object sender, RoutedEventArgs e)
{
_viewModel.Playlist.Title = tbkPlaylistTitle.Text;
_viewModel.Playlist.Descr = tbkPlaylistDescr.Text;
_viewModel.Playlist.Looping = PlaylistHelper.GetLoopingState((string)cbxLoopingState.SelectedItem);
_viewModel.Playlist.SinglePlaybackDuration = tbxSinglePlayDurationTime.Text;
_viewModel.Playlist.SinglePlaybackInterval = tbxSinglePlayIntervalTime.Text;
_viewModel.Playlist.StopPlaybackDuration = tbxTotalPlayDurationTime.Text;
PlaylistHelper.SaveOptions(_viewModel.Playlist, _lastRecord.Playlist);
Snackbar.MessageQueue.Enqueue(InternalResources.PlaylistSaved);
btnSave.IsEnabled = false;
}
/// <summary>
/// Create a playlist item given a track id
/// </summary>
/// <param name="trackId">track id</param>
/// <returns>Playlist item</returns>
internal static MediaPortal.Playlists.PlayListItem CreatePlaylistItemFromMusicTrack(int trackId)
{
PlayListItem item = null;
List <Song> songs = new List <Song>();
string sql = "select * from tracks where idTrack=" + trackId;
DatabaseUtility.RemoveInvalidChars(sql);
MusicDatabase.Instance.GetSongsByFilter(sql, out songs, "tracks");
if (songs.Count > 0)
{
item = PlaylistHelper.ToPlayListItem(songs[0]);
}
return(item);
}
public override async void Execute(object parameter)
{
if (Locator.MusicLibraryVM.Tracks == null || !Locator.MusicLibraryVM.Tracks.Any())
{
return;
}
var itemClickArgs = parameter as ItemClickEventArgs;
var index = 0;
if (itemClickArgs != null)
{
var selectedTrack = itemClickArgs.ClickedItem as TrackItem;
index = Locator.MusicLibraryVM.Tracks.IndexOf(selectedTrack);
}
await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(Locator.MusicLibraryVM.Tracks.ToPlaylist(), true, index);
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
}
/// <summary>
/// Create a playlist item given a artist id
/// </summary>
/// <param name="albumArtist">Album Artist</param>
/// <returns>Playlist items</returns>
internal static List <PlayListItem> CreatePlaylistItemsFromMusicArtist(string albumArtist)
{
List <PlayListItem> returnList = new List <PlayListItem>();
List <Song> songs = new List <Song>();
string sql = String.Format("select * from tracks where strAlbumArtist like '%{0}%'",
DatabaseUtility.RemoveInvalidChars(albumArtist));
MusicDatabase.Instance.GetSongsByFilter(sql, out songs, "tracks");
if (songs.Count > 0)
{
foreach (Song s in songs)
{
returnList.Add(PlaylistHelper.ToPlayListItem(s));
}
}
return(returnList);
}
public override async void Execute(object parameter)
{
Locator.NavigationService.GoBack_HideFlyout();
Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
Locator.MusicLibraryVM.IsAlbumPageShown = false;
TrackItem track = null;
if (parameter is ItemClickEventArgs)
{
var args = parameter as ItemClickEventArgs;
track = args.ClickedItem as TrackItem;
}
if (track == null)
{
// if the track is still null (for some reason), we need to break early.
return;
}
await PlaylistHelper.AddAlbumToPlaylist(track.AlbumId, true, true, track);
}
private void LoadPlaylist(string fileName)
{
_lastRecord = _viewModel.Playback.Records.SingleOrDefault(r => r.Playlist == fileName);
if (_lastRecord.IsNull())
{
_lastRecord = new RecordOptions();
_viewModel.Playback.Records.Add(_lastRecord);
}
if (_lastRecord.Playlist != fileName)
{
_lastRecord.Playlist = fileName;
}
_viewModel.Playlist = PlaylistHelper.LoadOptions(fileName);
_viewModel.ClearPlayback();
EnableControls();
}
/// <summary>
/// Handle an MpExtended message received from a client
/// </summary>
/// <param name="message">Message</param>
/// <param name="socketServer">Socket server</param>
/// <param name="sender">Sender</param>
internal static void HandleMpExtendedMessage(Newtonsoft.Json.Linq.JObject message, SocketServer socketServer, Deusty.Net.AsyncSocket sender)
{
string itemId = (string)message["ItemId"];
int itemType = (int)message["MediaType"];
int providerId = (int)message["ProviderId"];
String action = (String)message["Action"];
Dictionary <string, string> values = JsonConvert.DeserializeObject <Dictionary <string, string> >(message["PlayInfo"].ToString());
int startPos = (message["StartPosition"] != null) ? (int)message["StartPosition"] : 0;
if (action != null)
{
if (action.Equals("play"))
{
//play the item in MediaPortal
WifiRemote.LogMessage("play mediaitem: ItemId: " + itemId + ", itemType: " + itemType + ", providerId: " + providerId, WifiRemote.LogType.Debug);
MpExtendedHelper.PlayMediaItem(itemId, itemType, providerId, values, startPos);
}
else if (action.Equals("show"))
{
//show the item details in mediaportal (without starting playback)
WifiRemote.LogMessage("show mediaitem: ItemId: " + itemId + ", itemType: " + itemType + ", providerId: " + providerId, WifiRemote.LogType.Debug);
MpExtendedHelper.ShowMediaItem(itemId, itemType, providerId, values);
}
else if (action.Equals("enqueue"))
{
//enqueue the mpextended item to the currently active playlist
WifiRemote.LogMessage("enqueue mediaitem: ItemId: " + itemId + ", itemType: " + itemType + ", providerId: " + providerId, WifiRemote.LogType.Debug);
int startIndex = (message["StartIndex"] != null) ? (int)message["StartIndex"] : -1;
PlayListType playlistType = PlayListType.PLAYLIST_VIDEO;
List <PlayListItem> items = MpExtendedHelper.CreatePlayListItemItem(itemId, itemType, providerId, values, out playlistType);
PlaylistHelper.AddPlaylistItems(playlistType, items, startIndex);
}
}
else
{
WifiRemote.LogMessage("No MpExtended action defined", WifiRemote.LogType.Warn);
}
}
/// <summary>
/// Plays all songs from the given artist, starting with item defined by startPos
/// </summary>
/// <param name="albumArtist">Artist that is played</param>
/// <param name="startPos">Position from where playback is started (playlist index)</param>
internal static void PlayArtist(string albumArtist, int startPos)
{
List <Song> songs = new List <Song>();
string sql = String.Format("select * from tracks where strAlbumArtist like '%{0}%'",
DatabaseUtility.RemoveInvalidChars(albumArtist));
MusicDatabase.Instance.GetSongsByFilter(sql, out songs, "tracks");
if (songs.Count > 0)
{
PlaylistHelper.ClearPlaylist("music", false);
List <PlayListItem> items = new List <PlayListItem>();
foreach (Song s in songs)
{
items.Add(PlaylistHelper.ToPlayListItem(s));
}
PlaylistHelper.AddPlaylistItems(PlayListType.PLAYLIST_MUSIC, items, 0);
PlaylistHelper.StartPlayingPlaylist("music", startPos, true);
}
}
public async Task <IEnumerable <Mediafile> > LoadPlaylist(StorageFile file)
{
using (var streamReader = new StreamReader(await file.OpenStreamForReadAsync()))
{
List <string> playlistSongs = new List <string>();
string line;
int index = 0;
bool ext = false;
while ((line = streamReader.ReadLine()) != null)
{
if (line.ToLower() == "#extm3u") //m3u header
{
ext = true;
}
else if (ext && line.ToLower().StartsWith("#extinf:")) //extinfo of each song
{
continue;
}
else if (line.StartsWith("#") || line == "") //pass blank lines
{
continue;
}
else
{
await Task.Run(() =>
{
index++;
FileInfo info = new FileInfo(file.Path); //get playlist file info to get directory path
string path = line;
if (!File.Exists(line) && line[1] != ':') // if file doesn't exist then perhaps the path is relative
{
path = info.DirectoryName + line; //add directory path to song path.
}
playlistSongs.Add(path);
});
}
}
return(await PlaylistHelper.GetSongsInAllFoldersAsync(playlistSongs).ConfigureAwait(false));
}
}
public ClosePlaylistCommand(PlaylistHelper playlistHelper)
{
this.playlistHelper = playlistHelper;
}
static int ProcessRbXml(CommandOption argRkbXml, CommandOption argCommand, CommandOption argOutputDir, CommandOption argPlaylists,
CommandOption argMusicDir, out Parameters parameters)
{
Parameters prms = new Parameters();
if (argRkbXml.HasValue())
{
prms.InputRekordboxXML = argRkbXml.Value();
prms.ShowStatisticsCommand = argCommand.HasValue() && argCommand.Value() == COMMAND_SHOW_STATISTICS;
prms.GeneratePlaylistsCommand = argCommand.HasValue() && argCommand.Value() == COMMAND_GENERATE_PLAYLISTS;
prms.GenerateScriptsCommand = argCommand.HasValue() && argCommand.Value() == COMMAND_GENERATE_PLAYLISTS;
if (argPlaylists.HasValue() && argOutputDir.HasValue())
{
string Playlists = argPlaylists.Value().ToLowerInvariant();
prms.GeneratePlaylistsCommand = true;
prms.OutputDirectory = argOutputDir.Value();
prms.OrphanedPlaylistOption = Playlists.Contains(PLAYLIST_TOKEN_ORPHANS);
prms.DuplicatePlaylistOption = Playlists.Contains(PLAYLIST_TOKEN_DUPLICATES);
prms.UnanalyzedPlaylistOption = Playlists.Contains(PLAYLIST_TOKEN_UNANALYZED);
prms.MissingPlaylistOption = Playlists.Contains(PLAYLIST_TOKEN_MISSING);
prms.UntaggedPlaylistOption = Playlists.Contains(PLAYLIST_TOKEN_UNTAGGED);
prms.UnreferencedPlaylistOption = Playlists.Contains(PLAYLIST_TOKEN_UNREFERENCED);
}
Console.WriteLine("Loading Rekordbox.xml file in {0}...", argRkbXml.Value());
DJ_PLAYLISTS m2 = new DJ_PLAYLISTS(argRkbXml.Value());
Console.WriteLine("{0} track(s) loaded !", m2.Collection.Tracks.Length.ToString());
Console.WriteLine("{0} Playlists loaded !", m2.Playlists.Where(p => p.Type == 1).Count().ToString());
Console.WriteLine("Starting analysis...");
if (argCommand.HasValue() && argCommand.Value() == COMMAND_SHOW_STATISTICS)
{
Console.WriteLine("Calculating music library files size...");
Console.WriteLine("Total size : {0} Bytes", m2.Size);
}
else if (argPlaylists.HasValue() && argOutputDir.HasValue())
{
string Playlists = argPlaylists.Value().ToLowerInvariant();
string Destination;
if (Playlists.Contains(PLAYLIST_TOKEN_ORPHANS))
{
Destination = Path.Combine(argOutputDir.Value(), "Orphans.m3u8");
Console.WriteLine("Writing Orphans playlist to {0}...", Destination);
PlaylistHelper.WritePlaylist(m2.Orphans, Destination);
}
if (Playlists.Contains(PLAYLIST_TOKEN_DUPLICATES))
{
Destination = Path.Combine(argOutputDir.Value(), "Duplicates.m3u8");
Console.WriteLine("Writing Duplicates playlist to {0}...", Destination);
PlaylistHelper.WritePlaylist(m2.Duplicates, Destination);
}
if (Playlists.Contains(PLAYLIST_TOKEN_UNANALYZED))
{
Destination = Path.Combine(argOutputDir.Value(), "Unanalyzed.m3u8");
Console.WriteLine("Writing Unanalyzed playlist to {0}...", Destination);
PlaylistHelper.WritePlaylist(m2.UnAnalyzed, Destination);
}
if (Playlists.Contains(PLAYLIST_TOKEN_MISSING))
{
Destination = Path.Combine(argOutputDir.Value(), "Missing.m3u8");
Console.WriteLine("Writing Missing playlist to {0}...", Destination);
PlaylistHelper.WritePlaylist(m2.Missing, Destination);
}
if (Playlists.Contains(PLAYLIST_TOKEN_UNTAGGED))
{
Destination = Path.Combine(argOutputDir.Value(), "Untagged.m3u8");
Console.WriteLine("Writing Untagged playlist to {0}...", Destination);
PlaylistHelper.WritePlaylist(m2.Untagged, Destination);
}
if (Playlists.Contains(PLAYLIST_TOKEN_UNREFERENCED))
{
if (argMusicDir.HasValue())
{
Destination = Path.Combine(argOutputDir.Value(), "Unreferenced.m3u8");
Console.WriteLine("Writing Unreferenced playlist to {0}...", Destination);
PlaylistHelper.WritePlaylist(m2.Unreferenced(argMusicDir.Value()), Destination);
}
else
{
Console.WriteLine("Ignoring Missing playlist : no music folder provided !");
}
}
}
parameters = prms;
return(0);
}
else
{
parameters = null;
return(-1);
}
}
public MyRockRequestsCommand(PlaylistHelper playlistHelper)
{
this.playlistHelper = playlistHelper;
}
/// <summary>
/// Handles the DoWork event of the backgroundWorker control.
/// </summary>
private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
List <Track> availableTracks;
if (chkDisplayedTracksOnly.Checked)
{
availableTracks = _displayedTracks;
}
else
{
availableTracks = LibraryControl
.AvailableTracks
.Where(t => t.IsShufflerTrack)
.ToList();
}
var strategy =
(TrackSelector.MixStrategy)
Enum.Parse(typeof(TrackSelector.MixStrategy), cmbMode.GetTextThreadSafe().Replace(" ", ""));
Dictionary <string, Dictionary <string, Track> > excludedMixes = null;
if (txtExcludeTracks.Text != "" && File.Exists(txtExcludeTracks.Text))
{
var excludeTracks = PlaylistHelper.GetFilesInPlaylist(txtExcludeTracks.Text)
.Select(f => LibraryControl.Library.GetTrackByFilename(f))
.Where(t => t != null)
.ToList();
if (chkExlcudeMixesOnly.Checked)
{
if (excludeTracks.Count > 1)
{
excludedMixes = LibraryControl.MixLibrary.ConvertPlaylistToMixDictionary(excludeTracks);
}
}
else
{
var excludeTrackTitles = excludeTracks
.Select(t => t.Title)
.ToList();
availableTracks.RemoveAll(t => excludeTrackTitles.Contains(t.Title));
}
}
var bpmDirection =
(TrackSelector.BpmDirection)Enum.Parse(typeof(TrackSelector.BpmDirection), cmbBmpDirection.GetTextThreadSafe());
var direction =
(TrackSelector.GenerateDirection)Enum.Parse(typeof(TrackSelector.GenerateDirection), cmbDirection.GetTextThreadSafe());
var allowBearable =
(TrackSelector.AllowBearableMixStrategy)
Enum.Parse(typeof(TrackSelector.AllowBearableMixStrategy),
cmbAllowBearable.GetTextThreadSafe().Replace(" ", ""));
var approxLength = int.MaxValue;
if (_screenMode == ScreenMode.GeneratePlaylist)
{
var comboText = cmbApproxLength.GetTextThreadSafe().Replace(" minutes", "");
if (comboText != "No limit")
{
approxLength = Convert.ToInt32(comboText);
}
}
var continueMix =
(TrackSelector.ContinueMix)
Enum.Parse(typeof(TrackSelector.ContinueMix), cmbContinueMix.GetTextThreadSafe().Replace(" ", ""));
var keyMixStrategy =
(TrackSelector.KeyMixStrategy)
Enum.Parse(typeof(TrackSelector.KeyMixStrategy), cmbKeyMixing.GetTextThreadSafe().Replace(" ", ""));
var useExtendedMixes =
(TrackSelector.UseExtendedMixes)
Enum.Parse(typeof(TrackSelector.UseExtendedMixes),
cmbExtendedMixes.GetTextThreadSafe().Replace(" ", ""));
var tracksToAdd = int.MaxValue;
if (_screenMode == ScreenMode.AutoGeneratePlaylist)
{
tracksToAdd = Convert.ToInt32(cmbTracksToGenerate.GetTextThreadSafe());
}
var mixPath = TrackSelector.GeneratePlayList(availableTracks,
LibraryControl.MixLibrary,
PlaylistControl.GetTracks(),
bpmDirection,
approxLength,
allowBearable,
strategy,
useExtendedMixes,
excludedMixes,
chkRestrictArtistClumping.Checked,
chkRestrictGenreClumping.Checked,
chkRestrictTitleClumping.Checked,
continueMix,
keyMixStrategy,
tracksToAdd,
direction);
if (!_cancel)
{
if (InvokeRequired)
{
BeginInvoke(new MethodInvoker(() => QueueTracks(mixPath, direction)));
}
else
{
QueueTracks(mixPath, direction);
}
}
}
public VipCommand(VipHelper vipHelper, PlaylistHelper playlistHelper)
{
this.vipHelper = vipHelper;
this.playlistHelper = playlistHelper;
}
