Пример #1
0
        internal async void OnMixButtonCommand(object param)
        {
            if (IsMixDiscFilterValid())
            {
                _mixDiscTracks.Clear();
                var playlistTracks     = new ObservableCollection <ISong>(ImportedTrackCollection.Where(t => t.Playlist == SelectedMixDiscPlaylistComboBoxItem)).ToList();
                var playlistTrackCount = playlistTracks.Count();
                var tasks = new List <Task>(playlistTrackCount);

                ResetProgressBar();
                ProgressBarMax = playlistTrackCount;
                var minPlaytime = (Convert.ToInt32(PlaytimeTextBoxText) * 60);
                var mixLength   = Convert.ToInt32(MixLengthTextBoxText);
                ProgressBarValue = MixDiscCollection.Count();

                foreach (var track in playlistTracks)
                {
                    var baseTrackList = MixDiscCollection.ToList();
                    var task          = FindMixDiscTracksAsync(track, baseTrackList, playlistTracks, SelectedIntensityComboBoxItem, minPlaytime, mixLength);
                    tasks.Add(task);
                }

                await Task.WhenAll(tasks);
            }
        }
Пример #2
0
        public ObservableCollection <ISong> GetFilteredTrackCollection()
        {
            // merge in mixableRange tempo so we get the track tempo as a double rather than the tempo slider value as a int, for when getting next
            var slowestTempoSliderValue = Math.Round(Convert.ToDouble(TempoSliderValue), 3);
            var fastestTempoSliderValue = Math.Round(Convert.ToDouble(TempoSliderValue + 1), 3);

            // refactor ito Range project
            var tempoRangeValue = GetTempoRangeValue();

            var slowestTempoSliderRangeValue = Math.Round((slowestTempoSliderValue - tempoRangeValue), 3);
            var fastestTempoSliderRangeValue = Math.Round((fastestTempoSliderValue + tempoRangeValue), 3);

            _harmonicKeyRange.Load(SelectedHarmonicKeyComboBoxItem);

            _trackSearch.Reset();
            _trackSearch.Text = SearchTextBoxText;
            _trackSearch.Load();

            var selectedPlaylists = PlaylistCollection.Where(p => p.Selected);

            return(new ObservableCollection <ISong>(ImportedTrackCollection.Where(t =>
                                                                                  // not in preparation list
                                                                                  (!PreparationCollection.Contains(t)
                                                                                  // and playlist is selected
                                                                                   && (selectedPlaylists.FirstOrDefault(p => p.Path == Path.GetDirectoryName(t.Path)) != null)
                                                                                  // and (exact filter match
                                                                                   && ((!IsMixableRangeCheckboxChecked &&
                                                                                        (TempoSliderValue == 0 ||
                                                                                         (Math.Round(t.LeadingTempo, 3) >= slowestTempoSliderValue &&
                                                                                          Math.Round(t.LeadingTempo, 3) <= fastestTempoSliderValue)) &&
                                                                                        (string.IsNullOrEmpty(SelectedHarmonicKeyComboBoxItem) ||
                                                                                         t.LeadingHarmonicKey == SelectedHarmonicKeyComboBoxItem))
                                                                                       // or mixable range filter match)
                                                                                       || (IsMixableRangeCheckboxChecked &&
                                                                                           ((TempoSliderValue == 0 ||
                                                                                             (Math.Round(t.LeadingTempo, 3) >= slowestTempoSliderRangeValue &&
                                                                                              Math.Round(t.LeadingTempo, 3) <= fastestTempoSliderRangeValue)) &&
                                                                                            ((string.IsNullOrEmpty(SelectedHarmonicKeyComboBoxItem) ||
                                                                                              (t.LeadingHarmonicKey == _harmonicKeyRange.InnerCircleHarmonicKey ||
                                                                                               t.LeadingHarmonicKey == _harmonicKeyRange.OuterCircleHarmonicKey ||
                                                                                               t.LeadingHarmonicKey == _harmonicKeyRange.PlusOneHarmonicKey ||
                                                                                               t.LeadingHarmonicKey == _harmonicKeyRange.MinusOneHarmonicKey))))))
                                                                                   // and matches playlist
                                                                                   && (string.IsNullOrEmpty(SelectedPlaylistComboBoxItem) ||
                                                                                       t.Playlist == SelectedPlaylistComboBoxItem)
                                                                                   // and matches search text
                                                                                   && (string.IsNullOrEmpty(_trackSearch.Text) ||
                                                                                       t.Artist.ToLower().Contains(_trackSearch.Text.ToLower().Trim()) ||
                                                                                       t.Title.ToLower().Contains(_trackSearch.Text.ToLower().Trim())) ||
                                                                                   (!string.IsNullOrEmpty(_trackSearch.Artist) &&
                                                                                    !string.IsNullOrEmpty(_trackSearch.Title) &&
                                                                                    ((t.Artist.ToLower().Contains(_trackSearch.Artist.ToLower()) &&
                                                                                      t.Title.ToLower().Contains(_trackSearch.Title.ToLower())) ||
                                                                                     (t.Artist.ToLower().Contains(_trackSearch.Title.ToLower()) &&
                                                                                      t.Title.ToLower().Contains(_trackSearch.Artist.ToLower()))))
                                                                                  ))));
        }
Пример #3
0
 internal void OnClearMenuCommand(object param)
 {
     if (ImportedTrackCollection.Count() > 0)
     {
         if (MessageBox.Show("Are you sure you want to clear the playlists?", "Clear playlists", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
         {
             ClearPlaylists();
         }
     }
 }
Пример #4
0
 internal void ClearPlaylists()
 {
     FilteredTrackCollection.Clear();
     ImportedTrackCollection.Clear();
     PreparationCollection.Clear();
     MixDiscCollection.Clear();
     ClearFilter();
     ClearMixDiscFilter();
     _mixDiscTracks = new List <List <ISong> >();
     EnableControls();
     EnableMixDiscControls();
     ProgressBarMessage = "Ready to import";
 }
Пример #5
0
        internal async void OnImportMenuCommand(object param)
        {
            ClearPlaylists();
            _songListModel.TraktorLibrary.SetCollectionPath();

            if (_songListModel.TraktorLibrary.IsCollectionFound())
            {
                _songListModel.IsProgressBarIndeterminate = true;
                await Task.Run(() => _songListModel.TraktorLibrary.DeleteWorkingCollection());

                await Task.Run(() => _songListModel.TraktorLibrary.CreateWorkingCollection());

                await Task.Run(() => _songListModel.TraktorLibrary.LoadWorkingCollection());

                ProgressBarMax = await Task.Run(() => _songListModel.TraktorLibrary.GetSongCount());

                IsProgressBarIndeterminate = false;

                if (!string.IsNullOrEmpty(_songListModel.TraktorLibrary.WorkingCollection))
                {
                    _xmlWrapper.XmlPath = _songListModel.TraktorLibrary.WorkingCollectionPath;
                    _xmlWrapper.Load();

                    foreach (XmlNode collectionNode in _xmlWrapper.XmlDocument.DocumentElement.SelectNodes("/NML/COLLECTION"))
                    {
                        foreach (XmlNode entryNode in collectionNode.SelectNodes("ENTRY"))
                        {
                            ISong song = await Task.Run(() => GetSong(entryNode));

                            ImportedTrackCollection.Add(song);

                            if (!PlaylistComboBoxCollection.Contains(song.Playlist))
                            {
                                PlaylistComboBoxCollection.Add(song.Playlist);
                            }

                            var playlist = new Playlist {
                                Name = song.Playlist, Path = Path.GetDirectoryName(song.Path), Selected = true
                            };

                            if (PlaylistCollection.FirstOrDefault(p => p.Path == playlist.Path) == null)
                            {
                                PlaylistCollection.Add(playlist);
                            }

                            ProgressBarValue++;
                        }
                    }
                }

                PlaylistComboBoxCollection        = new ObservableCollection <string>(PlaylistComboBoxCollection.OrderBy(p => p));
                MixDiscPlaylistComboBoxCollection = new ObservableCollection <string>(PlaylistComboBoxCollection);
                PlaylistCollection = new ObservableCollection <IPlaylist>(PlaylistCollection.OrderBy(p => p.Path));
                Filter();

                if (FilteredTrackCollection.Count > 0)
                {
                    SelectedTrackCollectionItem = FilteredTrackCollection[0];
                }

                EnableControls();
                var statusMessage = string.Concat(ImportedTrackCollection.Count.ToString(), " tracks imported from Traktor collection");
                ProgressBarMessage = statusMessage;
                MessageBox.Show(string.Concat(statusMessage, "."));
            }
            else
            {
                ProgressBarMessage = "No Traktor collection found";
                MessageBox.Show("No Traktor collection found.");
            }

            ResetProgressBar(false);
        }