public IEnumerable <LibraryItem> GetItems(LibraryHierarchyNode libraryHierarchyNode, bool loadMetaData) { using (var database = this.DatabaseFactory.Create()) { using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel)) { var items = database.ExecuteEnumerator <LibraryItem>(database.Queries.GetLibraryItems(this.Filter), (parameters, phase) => { switch (phase) { case DatabaseParameterPhase.Fetch: parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId; parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id; parameters["loadMetaData"] = loadMetaData; parameters["metaDataType"] = META_DATA_TYPE; break; } }, transaction); foreach (var item in items) { item.InitializeComponent(this.Core); yield return(item); } } } }
protected virtual async Task AddPlaylistItems(LibraryHierarchyNode libraryHierarchyNode, string filter) { using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_HIGH, async cancellationToken => { using (var transaction = this.Database.BeginTransaction(this.Database.PreferredIsolationLevel)) { this.Offset = await this.Database.ExecuteScalarAsync <int>(this.Database.Queries.AddLibraryHierarchyNodeToPlaylist(filter, this.Sort.Value), (parameters, phase) => { switch (phase) { case DatabaseParameterPhase.Fetch: parameters["playlistId"] = this.Playlist.Id; parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId; parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id; parameters["sequence"] = this.Sequence; parameters["status"] = PlaylistItemStatus.Import; break; } }, transaction).ConfigureAwait(false); transaction.Commit(); } })) { await task.Run().ConfigureAwait(false); } }
protected virtual IEnumerable <LibraryHierarchyNode> GetNodesCore(LibraryHierarchyNode libraryHierarchyNode, string filter) { using (var database = this.DatabaseFactory.Create()) { using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel)) { var nodes = database.ExecuteEnumerator <LibraryHierarchyNode>(database.Queries.GetLibraryHierarchyNodes(filter), (parameters, phase) => { switch (phase) { case DatabaseParameterPhase.Fetch: parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId; parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id; break; } }, transaction); foreach (var node in nodes) { node.Parent = libraryHierarchyNode; node.InitializeComponent(this.Core); yield return(node); } } } }
private void DrawImage(LibraryHierarchyNode libraryHierarchyNode, DrawingContext context, int position, int count, int width, int height) { var id = this.GetImageId(libraryHierarchyNode, width, height) + position; var fileName = libraryHierarchyNode.MetaDatas[position].Value; if (!File.Exists(fileName)) { return; } var region = this.GetRegion(context, position, count, width, height); var size = (int)Math.Max(region.Width, region.Height); var source = this.ImageLoader.Load(id, fileName, size, size, false); if (source == null) { //Image failed to load, nothing can be done. return; } if (region.Width != region.Height) { source = this.CropImage(source, region, width, height); source.Freeze(); } context.DrawImage(source, region); }
public LibraryHierarchyNode GetNode(LibraryHierarchy libraryHierarchy, LibraryHierarchyNode libraryHierarchyNode) { var libraryHierarchyNodes = new List <LibraryHierarchyNode>() { libraryHierarchyNode }; while (libraryHierarchyNode.Parent != null) { libraryHierarchyNodes.Insert(0, libraryHierarchyNode.Parent); libraryHierarchyNode = libraryHierarchyNode.Parent; } for (var a = 0; a < libraryHierarchyNodes.Count; a++) { if (a == 0) { libraryHierarchyNodes[a] = this.GetNodes(libraryHierarchy).Find(libraryHierarchyNodes[a]); } else { libraryHierarchyNodes[a] = this.GetNodes(libraryHierarchyNodes[a - 1]).Find(libraryHierarchyNodes[a]); } libraryHierarchyNode = libraryHierarchyNodes[a]; if (libraryHierarchyNode == null) { //A node failed to refresh, cannot continue as we don't know what the new parent is. return(null); } } return(libraryHierarchyNode); }
public Task Add(Playlist playlist, LibraryHierarchyNode libraryHierarchyNode, bool clear) { Logger.Write(this, LogLevel.Debug, "Adding library node to playlist."); var index = this.PlaylistBrowser.GetInsertIndex(this.SelectedPlaylist); return(this.Insert(playlist, index, libraryHierarchyNode, clear)); }
private IDatabaseReader GetReader(IDatabaseComponent database, LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType?metaDataItemType, string metaDataItemName, ITransactionSource transaction) { return(database.ExecuteReader(database.Queries.GetLibraryHierarchyMetaData(this.LibraryHierarchyBrowser.Filter), (parameters, phase) => { switch (phase) { case DatabaseParameterPhase.Fetch: parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id; if (metaDataItemType.HasValue) { parameters["type"] = metaDataItemType.Value; } else { parameters["type"] = null; } if (!string.IsNullOrEmpty(metaDataItemName)) { parameters["name"] = metaDataItemName; } else { parameters["name"] = null; } break; } }, transaction)); }
public ImageSource CreateImageSource(LibraryHierarchyNode libraryHierarchyNode, int width, int height, bool cache) { try { var id = this.GetImageId(libraryHierarchyNode, width, height); if (cache) { var fileName = default(string); if (FileMetaDataStore.Exists(PREFIX, id, out fileName)) { return(this.ImageLoader.Load(fileName, 0, 0, true)); } } using (KeyLock.Lock(id)) { if (cache) { var fileName = default(string); if (FileMetaDataStore.Exists(PREFIX, id, out fileName)) { return(this.ImageLoader.Load(fileName, 0, 0, true)); } } return(this.CreateImageSourceCore(libraryHierarchyNode, width, height, cache)); } } catch (Exception e) { Logger.Write(this, LogLevel.Error, "Error creating image source: {0}", e.Message); return(null); } }
public IEnumerable <MetaDataItem> GetMetaDatas(LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType metaDataItemType) { using (var database = this.DatabaseFactory.Create()) { using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel)) { using (var reader = database.ExecuteReader(database.Queries.GetLibraryHierarchyMetaData, (parameters, phase) => { switch (phase) { case DatabaseParameterPhase.Fetch: parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id; parameters["type"] = metaDataItemType; break; } }, transaction)) { foreach (var record in reader) { yield return(new MetaDataItem() { Value = record.Get <string>("Value") }); } } } } }
protected virtual async Task GetRating(LibraryHierarchyNode libraryHierarchyNode, Dictionary <byte, InvocationComponent> invocationComponents) { Logger.Write(this, LogLevel.Debug, "Determining rating for library hierarchy node: {0}", libraryHierarchyNode.Id); var rating = default(byte); var ratings = await this.MetaDataBrowser.GetMetaDatasAsync(libraryHierarchyNode, MetaDataItemType.Tag, CommonStatistics.Rating).ConfigureAwait(false); switch (ratings.Length) { case 0: Logger.Write(this, LogLevel.Debug, "Library hierarchy node {0} tracks have no rating.", libraryHierarchyNode.Id); rating = 0; break; case 1: if (!byte.TryParse(ratings[0].Value, out rating)) { Logger.Write(this, LogLevel.Warn, "Library hierarchy node {0} tracks have rating \"{1}\" which is in an unknown format.", libraryHierarchyNode.Id, rating); return; } Logger.Write(this, LogLevel.Debug, "Library hierarchy node {0} tracks have rating {1}.", libraryHierarchyNode.Id, rating); break; default: Logger.Write(this, LogLevel.Debug, "Library hierarchy node {0} tracks have multiple ratings.", libraryHierarchyNode.Id); return; } foreach (var key in invocationComponents.Keys) { var invocationComponent = invocationComponents[key]; if (key == rating) { invocationComponent.Attributes = (byte)(invocationComponent.Attributes | InvocationComponent.ATTRIBUTE_SELECTED); } } }
private ImageSource CreateImageSourceCore(LibraryHierarchyNode libraryHierarchyNode, int width, int height, bool cache) { var fileNames = libraryHierarchyNode.MetaDatas.Where( metaDataItem => metaDataItem.Type == MetaDataItemType.Image && File.Exists(metaDataItem.Value) ).Select( metaDataItem => metaDataItem.Value ).ToArray(); switch (this.ImageMode) { case LibraryBrowserImageMode.First: switch (fileNames.Length) { case 0: return null; default: return this.CreateImageSource1(libraryHierarchyNode, fileNames, width, height); } default: case LibraryBrowserImageMode.Compound: switch (fileNames.Length) { case 0: return null; case 1: return this.CreateImageSource1(libraryHierarchyNode, fileNames, width, height); case 2: return this.CreateImageSource2(libraryHierarchyNode, fileNames, width, height, cache); case 3: return this.CreateImageSource3(libraryHierarchyNode, fileNames, width, height, cache); default: return this.CreateImageSource4(libraryHierarchyNode, fileNames, width, height, cache); } } }
public AsyncResult <ImageBrush> Create(LibraryHierarchyNode libraryHierarchyNode) { if (libraryHierarchyNode == null) { return(AsyncResult <ImageBrush> .FromValue(this.FallbackValue.Value)); } var cache = string.IsNullOrEmpty(this.LibraryHierarchyBrowser.Filter); if (cache) { var brush = default(ImageBrush); if (this.Store.TryGetValue(libraryHierarchyNode, out brush)) { return(AsyncResult <ImageBrush> .FromValue(brush)); } } if (this.Width != this.TileSize.Value || this.Height != this.TileSize.Value) { this.CalculateTileSize(this.TileSize.Value, this.TileSize.Value); } return(new AsyncResult <ImageBrush>(this.FallbackValue.Value, this.Factory.StartNew(() => { if (cache) { return this.Store.GetOrAdd( libraryHierarchyNode, () => this.Create(libraryHierarchyNode, true) ); } else { return this.Create(libraryHierarchyNode, false); } }))); }
public async Task Add(LibraryHierarchyNode libraryHierarchyNode, bool clear) { Logger.Write(this, LogLevel.Debug, "Adding library node to playlist."); var index = await this.PlaylistBrowser.GetInsertIndex().ConfigureAwait(false); await this.Insert(index, libraryHierarchyNode, clear).ConfigureAwait(false); }
private async Task <IEnumerable <MetaDataItem> > GetMetaDatasCoreAsync(LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType?metaDataItemType, string metaDataItemName) { using (var database = this.DatabaseFactory.Create()) { using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel)) { using (var reader = this.GetReader(database, libraryHierarchyNode, metaDataItemType, metaDataItemName, transaction)) { using (var sequence = reader.GetAsyncEnumerator()) { var result = new List <MetaDataItem>(); while (await sequence.MoveNextAsync().ConfigureAwait(false)) { result.Add(new MetaDataItem() { Name = metaDataItemName, Type = metaDataItemType.GetValueOrDefault(), Value = sequence.Current.Get <string>("Value") }); } return(result); } } } } }
private IEnumerable <LibraryHierarchyNode> GetNodesCore(LibraryHierarchyNode libraryHierarchyNode) { foreach (var child in this.GetNodes(libraryHierarchyNode.LibraryHierarchyId, libraryHierarchyNode.Id)) { child.Parent = libraryHierarchyNode; yield return(child); } }
public async Task SetRating(LibraryHierarchyNode libraryHierarchyNode, byte rating) { using (var task = new UpdateLibraryRatingTask(libraryHierarchyNode, rating)) { task.InitializeComponent(this.Core); await this.OnBackgroundTask(task).ConfigureAwait(false); await task.Run().ConfigureAwait(false); } }
public Task SetRating(LibraryHierarchyNode libraryHierarchyNode, byte rating) { //TODO: Warning: Buffering a potentially large sequence. It might be better to run the query multiple times. var libraryItems = this.LibraryHierarchyBrowser.GetItems( libraryHierarchyNode, true ).ToArray(); return(this.SetRating(libraryItems, rating)); }
public async Task Add(Playlist playlist, LibraryHierarchyNode libraryHierarchyNode) { using (var task = new AddPlaylistTask(playlist, libraryHierarchyNode)) { task.InitializeComponent(this.Core); await this.OnBackgroundTask(task).ConfigureAwait(false); await task.Run().ConfigureAwait(false); } }
private ImageSource CreateImageSource2(LibraryHierarchyNode libraryHierarchyNode, string[] fileNames, int width, int height, bool cache) { var visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { this.DrawImage(fileNames[0], context, 0, 2, width, height); this.DrawImage(fileNames[1], context, 1, 2, width, height); } return this.Render(libraryHierarchyNode, visual, width, height, cache); }
private ImageSource CreateImageSource1(LibraryHierarchyNode libraryHierarchyNode, int width, int height) { var id = this.GetImageId(libraryHierarchyNode, width, height); var fileName = libraryHierarchyNode.MetaDatas[0].Value; if (!File.Exists(fileName)) { return(this.CreateImageSource0(libraryHierarchyNode, width, height)); } return(this.ImageLoader.Load(id, fileName, width, height, true)); }
private string GetImageId(LibraryHierarchyNode libraryHierarchyNode, int width, int height) { var hashCode = default(int); unchecked { hashCode = (hashCode * 29) + libraryHierarchyNode.Id.GetHashCode(); hashCode = (hashCode * 29) + width.GetHashCode(); hashCode = (hashCode * 29) + height.GetHashCode(); } return Math.Abs(hashCode).ToString(); }
private ImageSource CreateImageSource2(LibraryHierarchyNode libraryHierarchyNode, int width, int height) { var visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { this.DrawImage(libraryHierarchyNode, context, 0, 2, width, height); this.DrawImage(libraryHierarchyNode, context, 1, 2, width, height); } return(this.Render(libraryHierarchyNode, visual, width, height)); }
public async Task Insert(Playlist playlist, int index, LibraryHierarchyNode libraryHierarchyNode, bool clear) { Logger.Write(this, LogLevel.Debug, "Inserting library node into playlist at index: {0}", index); using (var task = new AddLibraryHierarchyNodeToPlaylistTask(playlist, index, libraryHierarchyNode, clear)) { task.InitializeComponent(this.Core); await this.OnBackgroundTask(task).ConfigureAwait(false); await task.Run().ConfigureAwait(false); } }
public async Task AddPlaylist(LibraryHierarchyNode libraryHierarchyNode) { var playlist = new Playlist() { Name = libraryHierarchyNode.Value, Enabled = true }; await this.PlaylistManager.Add(playlist, libraryHierarchyNode).ConfigureAwait(false); this.PlaylistManager.SelectedPlaylist = playlist; }
private async Task AddPlaylistItems(IDatabaseQuery query, LibraryHierarchyNode libraryHierarchyNode, ITransactionSource transaction) { this.Offset += await this.Database.ExecuteScalarAsync <int>(query, (parameters, phase) => { switch (phase) { case DatabaseParameterPhase.Fetch: parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId; parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id; parameters["sequence"] = this.Sequence; parameters["status"] = PlaylistItemStatus.Import; break; } }, transaction).ConfigureAwait(false); }
private ImageSource Render(LibraryHierarchyNode libraryHierarchyNode, DrawingVisual visual, int width, int height) { var target = new RenderTargetBitmap(width, height, DPIX, DPIY, PixelFormats.Pbgra32); target.Render(visual); var encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(target)); using (var stream = new MemoryStream()) { encoder.Save(stream); stream.Seek(0, SeekOrigin.Begin); FileMetaDataStore.Write(PREFIX, this.GetImageId(libraryHierarchyNode, width, height), stream); stream.Seek(0, SeekOrigin.Begin); } target.Freeze(); return(target); }
public ImageSource CreateImageSource(LibraryHierarchyNode libraryHierarchyNode, int width, int height) { var id = this.GetImageId(libraryHierarchyNode, width, height); var fileName = default(string); if (FileMetaDataStore.Exists(PREFIX, id, out fileName)) { return(this.ImageLoader.Load(id, fileName, 0, 0, true)); } //TODO: Setting throwOnTimeout = false so we ignore synchronization timeout. //TODO: I think there exists a deadlock bug in KeyLock but I haven't been able to prove it. using (KeyLock.Lock(id, TIMEOUT, false)) { if (FileMetaDataStore.Exists(PREFIX, id, out fileName)) { return(this.ImageLoader.Load(id, fileName, 0, 0, true)); } return(this.CreateImageSourceCore(libraryHierarchyNode, width, height)); } }
private ImageSource CreateImageSourceCore(LibraryHierarchyNode libraryHierarchyNode, int width, int height) { switch (libraryHierarchyNode.MetaDatas.Length) { case 0: return(this.CreateImageSource0(libraryHierarchyNode, width, height)); case 1: return(this.CreateImageSource1(libraryHierarchyNode, width, height)); case 2: return(this.CreateImageSource2(libraryHierarchyNode, width, height)); case 3: return(this.CreateImageSource3(libraryHierarchyNode, width, height)); default: return(this.CreateImageSource4(libraryHierarchyNode, width, height)); } }
protected virtual ImageBrush Create(LibraryHierarchyNode libraryHierarchyNode, bool cache) { var source = this.LibraryBrowserTileProvider.CreateImageSource( libraryHierarchyNode, this.PixelWidth, this.PixelWidth, cache ); if (source == null) { return(this.FallbackValue.Value); } var brush = new ImageBrush(source) { Stretch = Stretch.Uniform }; brush.Freeze(); return(brush); }
private IEnumerable <MetaDataItem> GetMetaDatasCore(LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType?metaDataItemType, string metaDataItemName) { using (var database = this.DatabaseFactory.Create()) { using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel)) { using (var reader = this.GetReader(database, libraryHierarchyNode, metaDataItemType, metaDataItemName, transaction)) { foreach (var record in reader) { yield return(new MetaDataItem() { Name = metaDataItemName, Type = metaDataItemType.GetValueOrDefault(), Value = record.Get <string>("Value") }); } } } } }