public Task LoadVideo(TrackItem trackItem)
{
Task task = Task.Run(() =>
{
IsLoaded = false;
MediaElement.Dispatcher.Invoke(() =>
{
MediaElement.Tag = trackItem;
MediaElement.Source = new Uri(trackItem.OriginalPath, UriKind.Absolute);
MediaElement.Volume = 0;
// ===
MediaElement.Visibility = Visibility.Hidden;
// ===
MediaElement.Play();
Console.WriteLine($"Load For {MediaElement.Name} Item");
});
while (!IsLoaded) // 로딩이 되지 않을 때 까지
{
Thread.Sleep(10);
}
MediaElement.Dispatcher.Invoke(() =>
{
Console.WriteLine($"Load Complete {MediaElement.Name} Item");
});
IsReadyForPlay = true;
});
Console.WriteLine("Loader LoadVideo 종료 (inner)");
return(task);
}
private void AddTrackToPlaylistAndPlay(TrackItem trackItem)
{
TrackItem playlistTrackItem = AddTrackItemToPlaylist(trackItem, true);
PlaylistTrackGrid.SelectedItem = playlistTrackItem;
StopMusic();
PlayButtonClick(null, null);
}
public override void ItemStarted(TrackItem sender, TimingEventArgs e)
{
soundPlayer.Open(new Uri(sender.OriginalPath));
soundPlayer.Play();
soundPlayer.Position = MediaTools.FrameToTimeSpan(e.Frame, e.TimeLine.FrameRate);
//Console.WriteLine($"At {e.Frame} Sound Started!!!!!!!!!!!!!!!");
}
public static async Task RemoveTrackFromCollectionAndDatabase(TrackItem trackItem)
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
Locator.MusicLibraryVM._trackDatabase.Remove(Locator.MusicLibraryVM.Tracks.FirstOrDefault(x => x.Path == trackItem.Path));
Locator.MusicLibraryVM.Tracks.Remove(Locator.MusicLibraryVM.Tracks.FirstOrDefault(x => x.Path == trackItem.Path));
var album = Locator.MusicLibraryVM.Albums.FirstOrDefault(x => x.Id == trackItem.AlbumId);
album?.Tracks.Remove(album.Tracks.FirstOrDefault(x => x.Path == trackItem.Path));
var artist = Locator.MusicLibraryVM.Artists.FirstOrDefault(x => x.Id == trackItem.ArtistId);
var artistalbum = artist?.Albums.FirstOrDefault(x => x.Id == trackItem.AlbumId);
artistalbum?.Tracks.Remove(artistalbum.Tracks.FirstOrDefault(x => x.Path == trackItem.Path));
if (album.Tracks.Count == 0)
{
// We should remove the album as a whole
Locator.MusicLibraryVM.Albums.Remove(album);
Locator.MusicLibraryVM._albumDatabase.Remove(album);
artist.Albums.Remove(artistalbum);
}
var playingTrack = Locator.MediaPlaybackViewModel.TrackCollection.Playlist.FirstOrDefault(x => x.Id == trackItem.Id);
if (playingTrack != null)
{
Locator.MediaPlaybackViewModel.TrackCollection.Playlist.Remove(playingTrack);
}
}
catch
{
}
});
}
public static void OutputInfo(TrackItem t)
{
string p1 = t.ToString();
string p2 = Convert.ToString((int)t, 2).PadLeft(5, '0');
Console.WriteLine($"{p2,-4} -- {p1}");
}
public void Remove(TrackItem track)
{
using (connection.Lock())
{
connection.Delete(track);
}
}
async Task <Uri> getThumbnail(string path)
{
Uri ret = null;
var decomp = path.Substring(1).Split('/');
if (decomp[1] == "track")
{
TrackItem track = await Locator.MediaLibrary.LoadTrackById(int.Parse(decomp[4]));
AlbumItem album = await Locator.MediaLibrary.LoadAlbum(track.AlbumId);
ret = new Uri(album.AlbumCoverFullUri);
}
else if (decomp[1] == "video")
{
VideoItem video = await Locator.MediaLibrary.LoadVideoById(int.Parse(decomp[3]));
ret = new Uri(video.PictureUri);
}
else
{
throw new ArgumentException("Wrong URL path");
}
return(ret);
}
async Task InsertIntoGroupTrack(TrackItem track)
{
try
{
var supposedFirstChar = Strings.HumanizedArtistFirstLetter(track.Name);
var firstChar = GroupedTracks.FirstOrDefault(x => (string)x.Key == supposedFirstChar);
if (firstChar == null)
{
var newChar = new GroupItemList <TrackItem>(track)
{
Key = supposedFirstChar
};
if (GroupedTracks == null)
{
return;
}
int i = GroupedTracks.IndexOf(GroupedTracks.LastOrDefault(x => string.Compare((string)x.Key, (string)newChar.Key) < 0));
i++;
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => GroupedTracks.Insert(i, newChar));
}
else
{
await DispatchHelper.InvokeInUIThread(CoreDispatcherPriority.Normal, () => firstChar.Add(track));
}
}
catch { }
}
public async Task serveMediaFile(string path)
{
var decomp = path.Substring(1).Split('/');
string localPath;
if (decomp[1] == "track")
{
TrackItem track = Locator.MediaLibrary.LoadTrackById(int.Parse(decomp[4]));
localPath = track.Path;
}
else if (decomp[1] == "video")
{
VideoItem video = Locator.MediaLibrary.LoadVideoById(int.Parse(decomp[3]));
localPath = video.Path;
}
else
{
throw new System.IO.FileNotFoundException();
}
string fileName = GetFileName(localPath);
StorageFile file = await StorageFile.GetFileFromPathAsync(localPath);
using (var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
using (IOutputStream output = socket.OutputStream)
{
{
// Send the header.
string header = String.Format("HTTP/1.1 200 OK\r\n" +
"Content-Type: application/octet-stream\r\n" +
"Content-Disposition: attachment; filename=\"{1}\";\r\n" +
"Content-Length: {0}\r\n" +
"Connection: close\r\n" +
"\r\n", stream.Size, fileName);
byte[] headerArray = Encoding.UTF8.GetBytes(header);
IBuffer buffer = headerArray.AsBuffer();
await output.WriteAsync(buffer);
}
{
// Send the file.
byte[] data = new byte[BufferSize];
IBuffer buffer = data.AsBuffer();
while (true)
{
buffer = await stream.ReadAsync(buffer, BufferSize, InputStreamOptions.Partial);
if (buffer.Length == 0)
{
break; // Connection closed.
}
await output.WriteAsync(buffer);
}
}
}
}
}
public string GetPrice(TrackItem item)
{
var xPath = "//meta[@property='product:price:amount']";
var result = FromAttribute(item.Url, xPath, "content");
return(result);
}
public void Update(TrackItem track)
{
using (connection.Lock())
{
connection.Update(track);
}
}
public TrackItem[] GetTrackItems(IWin32Window owner)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Title = "select KML file";
dialog.Filter = "kml file(*.kml)|*.kml|all file(*.*)|*.*||";
dialog.DefaultExt = ".kml";
dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
dialog.Multiselect = true;
if (DialogResult.OK == dialog.ShowDialog(owner))
{
List <TrackItem> result = new List <TrackItem>();
foreach (string targetPath in dialog.FileNames)
{
using (KMLReader kr = new KMLReader(targetPath, MAX_SPEED))
{
TrackItem item = kr.Read();
if (null != item)
{
result.Add(item);
}
}
}
if (0 < result.Count)
{
return(result.ToArray());
}
}
return(null);
}
/// <summary>
/// Determine the trackItems and their location in the given tracknode.
/// </summary>
/// <param name="tn">The tracknode in which to search for track items</param>
/// <returns>The list/set of track itemss together with their position information</returns>
public IEnumerable <ChartableTrackItem> GetItemsInTracknode(TrackNode tn)
{
if (cachedItems.ContainsKey(tn))
{
return(cachedItems[tn]);
}
List <ChartableTrackItem> tracknodeItems = new List <ChartableTrackItem>();
TrackVectorNode vectorNode = tn as TrackVectorNode;
if (vectorNode?.TrackItemIndices == null)
{
return(tracknodeItems);
}
foreach (int trackItemIndex in vectorNode.TrackItemIndices)
{
TrackItem trItem = trackDB.TrackItems[trackItemIndex];
if (trItem is PlatformItem || trItem is SpeedPostItem)
{
var travellerAtItem = new Traveller(tsectionDat, trackDB.TrackNodes, vectorNode, trItem.Location, Traveller.TravellerDirection.Forward);
if (travellerAtItem != null)
{
tracknodeItems.Add(new ChartableTrackItem(trItem, travellerAtItem));
}
}
}
tracknodeItems.Sort(new AlongTrackComparer());
cachedItems[tn] = tracknodeItems;
return(tracknodeItems);
}
public string GetPrice(TrackItem item)
{
var xPath = "//article[@role='article']";
var result = FromAttribute(item.Url, xPath, "data-minsingleprice");
return(result);
}
public TrackItem[] GetTrackItems(IWin32Window owner)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Title = "select gpx file";
dialog.Filter = "gpx file(*.gpx)|*.gpx|all file(*.*)|*.*||";
dialog.DefaultExt = ".gpx";
dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
dialog.Multiselect = true;
if (DialogResult.OK == dialog.ShowDialog(owner))
{
List <TrackItem> result = new List <TrackItem>();
foreach (string targetPath in dialog.FileNames)
{
TrackItem item = LoadGpxFile(targetPath);
if (null != item)
{
result.Add(item);
}
}
if (0 < result.Count)
{
return(result.ToArray());
}
}
return(null);
}
public override async void Execute(object parameter)
{
Locator.NavigationService.GoOnPlaybackStarted(VLCPage.MusicPlayerPage);
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;
}
var playlist = Locator.MediaLibrary.LoadTracksByAlbumId(track.AlbumId);
var item = playlist.Find((t) => t.Id == track.Id);
if (item == null)
{
return;
}
var idx = playlist.IndexOf(item);
await Locator.PlaybackService.SetPlaylist(playlist, idx);
}
public IPriceService Get(TrackItem item)
{
var host = _hostService.Parse(item.Url);
var priceService = _priceServices.FirstOrDefault(x => x.CanHandle(host));
return(priceService);
}
public async Task <TrackItem> GetTrackItemFromFile(StorageFile track, string token = null)
{
//TODO: Warning, is it safe to consider this a good idea?
var trackItem = musicDatabase.LoadTrackFromPath(track.Path);
if (trackItem != null)
{
return(trackItem);
}
MusicProperties trackInfos = null;
try
{
trackInfos = await track.Properties.GetMusicPropertiesAsync();
}
catch
{
}
trackItem = new TrackItem
{
ArtistName = (string.IsNullOrEmpty(trackInfos?.Artist)) ? Strings.UnknownArtist : trackInfos?.Artist,
AlbumName = trackInfos?.Album ?? Strings.UnknownAlbum,
Name = (string.IsNullOrEmpty(trackInfos?.Title)) ? track.DisplayName : trackInfos?.Title,
Path = track.Path,
Duration = trackInfos?.Duration ?? TimeSpan.Zero,
File = track,
};
if (!string.IsNullOrEmpty(token))
{
trackItem.Token = token;
}
return(trackItem);
}
public override async void Execute(object parameter)
{
TrackItem track = null;
if (parameter is ItemClickEventArgs)
{
var itemClickEventArgs = (ItemClickEventArgs)parameter;
track = itemClickEventArgs.ClickedItem as TrackItem;
}
else if (parameter is TrackItem)
{
track = (TrackItem)parameter;
}
if (track == null)
{
// if the track is still null (for some reason), we need to break early.
return;
}
if (Locator.NavigationService.CurrentPage == VLCPage.MusicPlayerPage ||
Locator.NavigationService.CurrentPage == VLCPage.CurrentPlaylistPage)
{
Locator.PlaybackService.SetPlaylistMedia(track);
}
else
{
await Locator.PlaybackService.SetPlaylist(new List <IMediaItem> {
track
});
}
}
public string GetPrice(TrackItem item)
{
var priceService = _priceServiceFactory.Get(item);
var price = priceService?.GetPrice(item);
return(price);
}
private void listBoxTracks_KeyDown(object sender, KeyEventArgs e)
{
ClearTrackInfo();
if (e.KeyCode == Keys.Delete)
{
if (listBoxTracks.SelectedItems.Count == 0)
{
return;
}
var list = new TrackItem[listBoxTracks.SelectedItems.Count];
listBoxTracks.SelectedItems.CopyTo(list, 0);
foreach (var track in list)
{
listBoxTracks.Items.Remove(track);
}
}
else if (e.KeyCode == Keys.A && e.Control)
{
var list = new TrackItem[listBoxTracks.Items.Count];
listBoxTracks.Items.CopyTo(list, 0);
listBoxTracks.SelectedItems.Clear();
foreach (var track in list)
{
listBoxTracks.SelectedItems.Add(track);
}
}
}
public override void ItemEnded(TrackItem sender, TimingEventArgs e)
{
if (Layer != null)
{
Layer.Source = null;
}
}
public override void TimeLineStopped()
{
Items.Clear();
lastLoadItem = null;
p1Playing = false;
DisablePlayer(player1);
DisablePlayer(player2);
}
public NewTrackLinkModel(ICosmosDBRepository <TrackItem> repositoryService, ICosmosDBRepository <ListCategory> categoryRepository, IActivityLog activityLogRepository)
{
this.repository = repositoryService;
this.categoryRepository = categoryRepository;
this.activityLog = activityLogRepository;
this.NewTrack = new TrackItem();
this.NewTrack.ListName = "Ausfahrten";
}
public override void ItemStarted(TrackItem sender, TimingEventArgs e)
{
if (Layer != null)
{
var rootCanvas = Layer.Parent as Canvas;
Layer.Source = new BitmapImage(new Uri(sender.OriginalPath));
//Layer.Width = rootCanvas.ActualWidth * sender.ItemProperty.Size;
//Layer.Height = rootCanvas.ActualHeight * sender.ItemProperty.Size;
//Canvas.SetLeft(Layer, (rootCanvas.ActualWidth - Layer.Width + (rootCanvas.ActualWidth * 2 * sender.ItemProperty.PositionX)) / 2);
//Canvas.SetTop(Layer, (rootCanvas.ActualHeight - Layer.Height + (rootCanvas.ActualHeight * 2 * sender.ItemProperty.PositionY)) / 2);
//sender.ItemProperty.PropertyChanged += (sen, ev) =>
//{
// switch (ev.ChangedProperty.ToLower())
// {
// case "opacity":
// Layer.Opacity = sender.ItemProperty.Opacity;
// break;
// case "positionx":
// case "positiony":
// case "size":
// Layer.Width = rootCanvas.ActualWidth * sender.ItemProperty.Size;
// Layer.Height = rootCanvas.ActualHeight * sender.ItemProperty.Size;
// Canvas.SetLeft(Layer, (rootCanvas.ActualWidth - Layer.Width + (rootCanvas.ActualWidth * 2 * sender.ItemProperty.PositionX)) / 2);
// Canvas.SetTop(Layer, (rootCanvas.ActualHeight - Layer.Height + (rootCanvas.ActualHeight * 2 * sender.ItemProperty.PositionY)) / 2);
// break;
// case "chromakeyusage":
// case "chromakeycolor":
// case "chromakeyenabled":
// if (sender.ItemProperty.ChromaKeyEnabled)
// {
// sender.ItemProperty.ChromaKeyColor.ToHSL(out double _h, out double _s, out double _l);
// Layer.Effect = new ChromaKeyEffect()
// {
// HueMin = (float)_h,
// HueMax = (float)_h,
// SaturationMax = (float)_s,
// SaturationMin = (float)_s,
// LuminanceMax = (float)_l,
// LuminanceMin = (float)_l,
// Smooth = (float)sender.ItemProperty.ChromaKeyUsage,
// };
// }
// else
// {
// Layer.Effect = null;
// }
// break;
// }
//};
}
}
public void lerp(TrackItem curItem, TrackItem nextItem, float percent)
{
LayoutTools.MOVE_WINDOW(mTrack, MathUtility.lerp(curItem.mOriginPosition, nextItem.mOriginPosition, percent));
LayoutTools.SCALE_WINDOW(mTrack, MathUtility.lerp(curItem.mOriginScale, nextItem.mOriginScale, percent));
mTrack.setDepth((int)MathUtility.lerp(curItem.mOriginTrackDepth, nextItem.mOriginTrackDepth, percent));
mChecked.setDepth((int)MathUtility.lerp(curItem.mOriginCheckedDepth, nextItem.mOriginCheckedDepth, percent));
mLabel.setDepth((int)MathUtility.lerp(curItem.mOriginLabelDepth, nextItem.mOriginLabelDepth, percent));
mTexture.setDepth((int)MathUtility.lerp(curItem.mOriginTextureDepth, nextItem.mOriginTextureDepth, percent));
}
/// <inheritdoc/>
public async Task <TrackItem> RemoveTrackAsync(TrackItem track)
{
track = await this.Tracks.Include(n => n.AlbumItem).Include(n => n.ArtistItem).FirstAsync(n => n.Id == track.Id).ConfigureAwait(false);
this.Tracks.Remove(track);
var rows = await this.SaveChangesAsync().ConfigureAwait(false);
return(track);
}
public bool Contains(TrackItem frame)
{
if (Name == frame.Name)
{
return(true);
}
return(next == null ? false : next.Contains(frame));
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="originalTrItem">The original track item that we are representing for drawing</param>
public DrawablePlatformItem(TrackItem originalTrItem)
: base(originalTrItem)
{
Description = "platform";
PlatformItem platform = originalTrItem as PlatformItem;
this.itemName = platform.ItemName;
this.stationName = platform.Station;
}
internal TrackItem Pop()
{
_current = _current.Detach();
if (_current == null)
{
_root = null;
}
return(_current);
}
/// <summary>
/// GPXファイルの読み込み
/// </summary>
/// <param name="filePath">GPXファイルのパス</param>
/// <returns>PGXから読み込んだ座標情報リスト</returns>
private static TrackItem LoadGpxFile(string filePath)
{
TrackItem result = null;
using (TrackItemReader tir = new TrackItemReader(filePath))
{
result = tir.Read();
}
return(result);
}
private void QueueTrack(TrackItem trackItem)
{
if (_streamItems == null) return;
Child child = trackItem.Child;
Uri fileNameUri = new Uri(trackItem.FileName);
if (_streamItems.All(s => s.OriginalString == trackItem.FileName) && trackItem.Cached)
{
// Use this to tell Subsonic we're playing back the track, this will result in the server indicating we have cancelled the data transfer, it isn't very nice.
//SubsonicClient.StreamAsync(child.Id, trackItem.FileName, _maxBitrate == 0 ? null : (int?) _maxBitrate, null, null, null, null, GetCancellationToken("QueueTrack"), true);
QueueTrackItemForPlayback(trackItem, false);
UpdateAlbumArt(child);
}
else
{
if (!_streamItems.Contains(fileNameUri))
_streamItems.Enqueue(fileNameUri);
UpdateAlbumArt(child);
_caching = true;
DownloadStatusLabel.Content = string.Format("Caching: {0}", child.Title);
var streamTask = SubsonicClient.StreamAsync(child.Id, trackItem.FileName, _maxBitrate == 0 ? null : (int?) _maxBitrate, null, null, null, null, GetCancellationToken("QueueTrack"));
QueueTrackItemForPlayback(trackItem, true);
streamTask.ContinueWith(t => QueueTrack(t, trackItem));
//if (_useDiskCache)
//{
// _caching = true;
// DownloadStatusLabel.Content = string.Format("Caching: {0}", child.Title);
// SubsonicClient.StreamAsync(child.Id, trackItem.FileName, _maxBitrate == 0 ? null : (int?)_maxBitrate, null, null, null, null, GetCancellationToken("QueueTrack")).ContinueWith(t => QueueTrack(t, trackItem));
//}
//else
//{
// QueueTrack(new Uri(SubsonicClient.BuildStreamUrl(child.Id)), trackItem); // Works with non-SSL servers
//}
}
}
private TrackItem AddTrackItemToPlaylist(TrackItem trackItem, bool playback = false, bool clear = true)
{
var playlistTrackItem = new TrackItem();
trackItem.CopyTo(playlistTrackItem);
playlistTrackItem.Source = trackItem;
playlistTrackItem.Duration = TimeSpan.FromSeconds(playlistTrackItem.Child.Duration);
playlistTrackItem.PlaylistGuid = Guid.NewGuid();
if (playback)
Dispatcher.Invoke(() =>
{
if (clear)
_playbackTrackItems.Clear();
_playbackTrackItems.Add(playlistTrackItem);
});
else
Dispatcher.Invoke(() => _playlistTrackItems.Add(playlistTrackItem));
return playlistTrackItem;
}
private void QueueTrack(Task task, TrackItem trackItem)
{
switch (task.Status)
{
case TaskStatus.RanToCompletion:
Dispatcher.Invoke(() =>
{
DownloadStatusLabel.Content = string.Empty;
Uri thisUri;
_streamItems.TryDequeue(out thisUri);
trackItem.Cached = IsTrackCached(trackItem.FileName, trackItem.Child);
_caching = false;
if (trackItem.Source != null)
trackItem.Source.Cached = trackItem.Cached;
//QueueTrack(thisUri, trackItem);
});
break;
}
}
internal void Push(TrackItem frame)
{
if (_root == null)
{
_root = _current = frame;
}
else
{
if (_root.Contains(frame))
throw new LoopDependencyException(_root.ToStackString());
_current.Attach(frame);
_current = frame;
}
}
public bool Contains(TrackItem frame)
{
if (Name == frame.Name)
{
return true;
}
return next == null ? false : next.Contains(frame);
}
private void QueueTrackItemForPlayback(TrackItem trackItem, bool stream)
{
Dispatcher.Invoke(() =>
{
try
{
StopMusic();
StreamProxy.SetTrackItem(trackItem);
string dataSource = stream ? string.Format("http://127.0.0.1:{0}/{1}", StreamProxy.GetPort(), HttpUtility.UrlEncode(trackItem.FileName, Encoding.UTF8)) : trackItem.FileName;
if (stream)
{
_position = TimeSpan.FromSeconds(trackItem.Child.Duration);
ProgressSlider.Minimum = 0;
ProgressSlider.Maximum = _position.TotalMilliseconds;
}
MediaPlayer.Source = new Uri(dataSource);
ProgressSlider.Value = 0;
_nowPlayingTrack = trackItem;
PlayMusic();
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Exception:\n\n{0}\n{1}", ex.Message, ex.StackTrace), AppName, MessageBoxButton.OK, MessageBoxImage.Error);
}
});
}
private void PlayTrack(TrackItem trackItem)
{
UpdateAlbumArt(trackItem.Child);
QueueTrack(trackItem);
}
public bool Equals(TrackItem obj)
{
if (ReferenceEquals(null, obj)) return false;
if (ReferenceEquals(this, obj)) return true;
return Equals(obj.Name, Name);
}
private void listBoxTracks_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Delete)
{
if (listBoxTracks.SelectedItems.Count == 0)
return;
var list = new TrackItem[listBoxTracks.SelectedItems.Count];
listBoxTracks.SelectedItems.CopyTo(list, 0);
foreach (var track in list)
listBoxTracks.Items.Remove(track);
}
else if (e.KeyCode == Keys.A && e.Control)
{
var list = new TrackItem[listBoxTracks.Items.Count];
listBoxTracks.Items.CopyTo(list, 0);
listBoxTracks.SelectedItems.Clear();
foreach (var track in list)
listBoxTracks.SelectedItems.Add(track);
}
}
public void Clear()
{
_current = _root = null;
}
private void FinalizeCache(Task<long> task, TrackItem trackItem)
{
Dispatcher.Invoke(() => DownloadStatusLabel.Content = string.Empty);
switch (task.Status)
{
case TaskStatus.RanToCompletion:
Dispatcher.Invoke(() =>
{
trackItem.Cached = IsTrackCached(trackItem.FileName, trackItem.Child);
if (trackItem.Source != null) trackItem.Source.Cached = trackItem.Cached;
_caching = false;
});
break;
}
}
internal TrackItem Pop()
{
_current = _current.Detach();
if (_current == null) _root = null;
return _current;
}
internal void Attach(TrackItem next)
{
this.next = next;
this.next.parent = this;
}
