From acca89315ee8ae3a0c0b4514827eb2cb73808741 Mon Sep 17 00:00:00 2001 From: Konstantin Date: Sat, 2 Feb 2013 15:47:01 +0400 Subject: add Caption to ViewModel --- Juick/Classes/ExpressionHelper.cs | 20 ++++++++++++++++++++ Juick/Juick.csproj | 1 + Juick/ThreadView.xaml | 2 +- Juick/ViewModels/MessageListViewModelBase.cs | 4 +++- Juick/ViewModels/ThreadViewModel.cs | 9 ++++++++- 5 files changed, 33 insertions(+), 3 deletions(-) create mode 100644 Juick/Classes/ExpressionHelper.cs diff --git a/Juick/Classes/ExpressionHelper.cs b/Juick/Classes/ExpressionHelper.cs new file mode 100644 index 0000000..3eb453a --- /dev/null +++ b/Juick/Classes/ExpressionHelper.cs @@ -0,0 +1,20 @@ +using System; +using System.Linq.Expressions; + +namespace Juick.Classes +{ + static class ExpressionHelper + { + public static string GetPropertyName(Expression> propertyExpression) + { + var bodyExpression = propertyExpression.Body; + var unaryExpression = bodyExpression as UnaryExpression; + if (unaryExpression != null) + { + bodyExpression = unaryExpression.Operand; + } + var memberExpression = (MemberExpression)bodyExpression; + return memberExpression.Member.Name; + } + } +} diff --git a/Juick/Juick.csproj b/Juick/Juick.csproj index c330761..c74da5b 100644 --- a/Juick/Juick.csproj +++ b/Juick/Juick.csproj @@ -73,6 +73,7 @@ + diff --git a/Juick/ThreadView.xaml b/Juick/ThreadView.xaml index 7de5533..ebfd166 100644 --- a/Juick/ThreadView.xaml +++ b/Juick/ThreadView.xaml @@ -23,7 +23,7 @@ - + diff --git a/Juick/ViewModels/MessageListViewModelBase.cs b/Juick/ViewModels/MessageListViewModelBase.cs index b9d7070..60c0a94 100644 --- a/Juick/ViewModels/MessageListViewModelBase.cs +++ b/Juick/ViewModels/MessageListViewModelBase.cs @@ -13,6 +13,7 @@ namespace Juick.ViewModels { public class MessageListViewModelBase : INotifyPropertyChanged { + static readonly string IsDataLoadingPropertyName = ExpressionHelper.GetPropertyName(x => x.IsDataLoading); bool isDataLoading; public MessageListViewModelBase() @@ -22,6 +23,7 @@ namespace Juick.ViewModels } public string RestUri { get; set; } + public virtual string Caption { get { return "juick"; } } /// /// A collection for MessageViewModel objects. @@ -36,7 +38,7 @@ namespace Juick.ViewModels set { isDataLoading = value; - NotifyPropertyChanged("IsDataLoading"); + NotifyPropertyChanged(IsDataLoadingPropertyName); LoadMessagesPageCommand.NotifyCanExecuteChanged(); } } diff --git a/Juick/ViewModels/ThreadViewModel.cs b/Juick/ViewModels/ThreadViewModel.cs index 4a80f31..ec1f92d 100644 --- a/Juick/ViewModels/ThreadViewModel.cs +++ b/Juick/ViewModels/ThreadViewModel.cs @@ -1,9 +1,11 @@ -using System; +using Juick.Classes; namespace Juick.ViewModels { public class ThreadViewModel : MessageListViewModelBase { + static readonly string CaptionPropertyName = ExpressionHelper.GetPropertyName(x => x.Caption); + private int _mid; public int Mid { @@ -12,7 +14,12 @@ namespace Juick.ViewModels { _mid = value; RestUri = string.Format("/thread?mid={0}", _mid); + NotifyPropertyChanged(CaptionPropertyName); } } + + public override string Caption { + get { return "#" + _mid; } + } } } -- cgit v1.2.3 From 3e83f498fdee386ee90730665f6be82fe01e3887 Mon Sep 17 00:00:00 2001 From: Konstantin Date: Wed, 13 Feb 2013 00:09:19 +0400 Subject: update icon --- Juick/ApplicationTile.png | Bin 4187 -> 5690 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/Juick/ApplicationTile.png b/Juick/ApplicationTile.png index 96d0872..703c107 100644 Binary files a/Juick/ApplicationTile.png and b/Juick/ApplicationTile.png differ -- cgit v1.2.3 From d06477d49cc8e8daf6f87c7b439c2a80515687f1 Mon Sep 17 00:00:00 2001 From: Konstantin Date: Sun, 24 Feb 2013 01:57:39 +0400 Subject: update tiles --- Juick/App.xaml.cs | 13 ++++++- Juick/ApplicationSmallTile.png | Bin 0 -> 3889 bytes Juick/ApplicationWideTile.png | Bin 0 -> 5534 bytes Juick/Classes/TileHelper.cs | 78 +++++++++++++++++++++++++++++++++++++ Juick/Juick.csproj | 5 ++- Juick/Properties/WMAppManifest.xml | 3 ++ 6 files changed, 97 insertions(+), 2 deletions(-) create mode 100644 Juick/ApplicationSmallTile.png create mode 100644 Juick/ApplicationWideTile.png create mode 100644 Juick/Classes/TileHelper.cs diff --git a/Juick/App.xaml.cs b/Juick/App.xaml.cs index 9d3ac9a..c0f6134 100644 --- a/Juick/App.xaml.cs +++ b/Juick/App.xaml.cs @@ -96,7 +96,18 @@ namespace Juick // This code will not execute when the application is reactivated private void Application_Launching(object sender, LaunchingEventArgs e) { - + const string JuickCaption = "Juick"; + TileHelper.UpdateFlipTile( + JuickCaption, + string.Empty, + JuickCaption, + JuickCaption, + null, + "/ApplicationSmallTile.png", + "/ApplicationTile.png", + null, + "/ApplicationWideTile.png", + null); } // Code to execute when the application is activated (brought to foreground) diff --git a/Juick/ApplicationSmallTile.png b/Juick/ApplicationSmallTile.png new file mode 100644 index 0000000..95947f4 Binary files /dev/null and b/Juick/ApplicationSmallTile.png differ diff --git a/Juick/ApplicationWideTile.png b/Juick/ApplicationWideTile.png new file mode 100644 index 0000000..e0b6bd6 Binary files /dev/null and b/Juick/ApplicationWideTile.png differ diff --git a/Juick/Classes/TileHelper.cs b/Juick/Classes/TileHelper.cs new file mode 100644 index 0000000..223340b --- /dev/null +++ b/Juick/Classes/TileHelper.cs @@ -0,0 +1,78 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.Phone.Shell; + +namespace Juick.Classes +{ + static class TileHelper + { + public static void UpdateFlipTile( + string title, + string backTitle, + string backContent, + string wideBackContent, + int? count, + string smallBackgroundImageStringUri, + string backgroundImageStringUri, + string backBackgroundImageStringUri, + string wideBackgroundImageStringUri, + string wideBackBackgroundImageStringUri) + { + if (!CanUseLiveTiles) + { + return; + } + var smallBackgroundImage = CreateRelativeUri(smallBackgroundImageStringUri); + var backgroundImage = CreateRelativeUri(backgroundImageStringUri); + var backBackgroundImage = CreateRelativeUri(backBackgroundImageStringUri); + var wideBackgroundImage = CreateRelativeUri(wideBackgroundImageStringUri); + var wideBackBackgroundImage = CreateRelativeUri(wideBackBackgroundImageStringUri); + + Type flipTileDataType = Type.GetType("Microsoft.Phone.Shell.FlipTileData, Microsoft.Phone"); + + // Get the ShellTile type so we can call the new version of "Update" that takes the new Tile templates. + Type shellTileType = Type.GetType("Microsoft.Phone.Shell.ShellTile, Microsoft.Phone"); + + // Loop through any existing Tiles that are pinned to Start. + foreach (var tileToUpdate in ShellTile.ActiveTiles) + { + var UpdateTileData = flipTileDataType.GetConstructor(new Type[] { }).Invoke(null); + + // Set the properties. + SetProperty(UpdateTileData, "Title", title); + SetProperty(UpdateTileData, "Count", count); + SetProperty(UpdateTileData, "BackTitle", backTitle); + SetProperty(UpdateTileData, "BackContent", backContent); + SetProperty(UpdateTileData, "SmallBackgroundImage", smallBackgroundImage); + SetProperty(UpdateTileData, "BackgroundImage", backgroundImage); + SetProperty(UpdateTileData, "BackBackgroundImage", backBackgroundImage); + SetProperty(UpdateTileData, "WideBackgroundImage", wideBackgroundImage); + SetProperty(UpdateTileData, "WideBackBackgroundImage", wideBackBackgroundImage); + SetProperty(UpdateTileData, "WideBackContent", wideBackContent); + + // Invoke the new version of ShellTile.Update. + shellTileType.GetMethod("Update").Invoke(tileToUpdate, new Object[] { UpdateTileData }); + } + } + + static Uri CreateRelativeUri(string uriString) + { + return !string.IsNullOrEmpty(uriString) ? new Uri(uriString, UriKind.Relative) : null; + } + + static void SetProperty(object instance, string name, object value) + { + var setMethod = instance.GetType().GetProperty(name).GetSetMethod(); + setMethod.Invoke(instance, new object[] { value }); + } + + static readonly Version targetedVersion78 = new Version(7, 10, 8858); + + static bool CanUseLiveTiles + { + get { return Environment.OSVersion.Version >= targetedVersion78; } + } + } +} diff --git a/Juick/Juick.csproj b/Juick/Juick.csproj index c74da5b..1ae974a 100644 --- a/Juick/Juick.csproj +++ b/Juick/Juick.csproj @@ -75,6 +75,7 @@ + LoginView.xaml @@ -142,7 +143,9 @@ - + + + diff --git a/Juick/Properties/WMAppManifest.xml b/Juick/Properties/WMAppManifest.xml index 8f7b6da..15e3611 100644 --- a/Juick/Properties/WMAppManifest.xml +++ b/Juick/Properties/WMAppManifest.xml @@ -33,5 +33,8 @@ + \ No newline at end of file -- cgit v1.2.3 From e00e4e7e75d53af5fcf06a90421f5ca69d35ccf3 Mon Sep 17 00:00:00 2001 From: Vitaly Takmazov Date: Sat, 2 Mar 2013 20:28:59 +0400 Subject: LowProfileImageLoader --- Juick/Classes/DeferredLoadListBox.cs | 275 +++++++++++++++++++++++++ Juick/Classes/DeferredLoadListBoxItem.cs | 45 ++++ Juick/Classes/LowProfileImageLoader.cs | 294 +++++++++++++++++++++++++++ Juick/Juick.csproj | 3 + Juick/MainPage.xaml | 4 +- Juick/ThreadView.xaml | 4 +- Juick/ViewModels/MessageListViewModelBase.cs | 8 +- Juick/ViewModels/MessageViewModel.cs | 12 +- 8 files changed, 632 insertions(+), 13 deletions(-) create mode 100644 Juick/Classes/DeferredLoadListBox.cs create mode 100644 Juick/Classes/DeferredLoadListBoxItem.cs create mode 100644 Juick/Classes/LowProfileImageLoader.cs diff --git a/Juick/Classes/DeferredLoadListBox.cs b/Juick/Classes/DeferredLoadListBox.cs new file mode 100644 index 0000000..165a395 --- /dev/null +++ b/Juick/Classes/DeferredLoadListBox.cs @@ -0,0 +1,275 @@ +// Copyright (C) Microsoft Corporation. All Rights Reserved. +// This code released under the terms of the Microsoft Public License +// (Ms-PL, http://opensource.org/licenses/ms-pl.html). + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Controls.Primitives; +using System.Windows.Data; +using System.Windows.Media; + +namespace Juick.Classes +{ + /// + /// Implements a subclass of ListBox based on a StackPanel that defers the + /// loading of off-screen items until necessary in order to minimize impact + /// to the UI thread. + /// + public class DeferredLoadListBox : ListBox + { + private enum OverlapKind { Overlap, ChildAbove, ChildBelow }; + + private ScrollViewer _scrollViewer; + private ItemContainerGenerator _generator; + private bool _queuedUnmaskVisibleContent; + private bool _inOnApplyTemplate; + + /// + /// Handles the application of the Control's Template. + /// + public override void OnApplyTemplate() + { + // Unhook from old Template elements + _inOnApplyTemplate = true; + ClearValue(VerticalOffsetShadowProperty); + _scrollViewer = null; + _generator = null; + + // Apply new Template + base.OnApplyTemplate(); + + // Hook up to new Template elements + _scrollViewer = FindFirstChildOfType(this); + if (null == _scrollViewer) + { + throw new NotSupportedException("Control Template must include a ScrollViewer (wrapping ItemsHost)."); + } + _generator = ItemContainerGenerator; + SetBinding(VerticalOffsetShadowProperty, new Binding { Source = _scrollViewer, Path = new PropertyPath("VerticalOffset") }); + _inOnApplyTemplate = false; + } + + /// + /// Determines if the specified item is (or is eligible to be) its own item container. + /// + /// The specified item. + /// true if the item is its own item container; otherwise, false. + protected override bool IsItemItsOwnContainerOverride(object item) + { + // Check container type + return item is DeferredLoadListBoxItem; + } + + /// + /// Creates or identifies the element used to display a specified item. + /// + /// A DeferredLoadListBoxItem corresponding to a specified item. + protected override DependencyObject GetContainerForItemOverride() + { + // Create container (matches ListBox implementation) + var item = new DeferredLoadListBoxItem(); + if (ItemContainerStyle != null) + { + item.Style = ItemContainerStyle; + } + return item; + } + + /// + /// Prepares the specified element to display the specified item. + /// + /// The element used to display the specified item. + /// The item to display. + protected override void PrepareContainerForItemOverride(DependencyObject element, object item) + { + // Perform base class preparation + base.PrepareContainerForItemOverride(element, item); + + // Mask the container's content + var container = (DeferredLoadListBoxItem)element; + if (!DesignerProperties.IsInDesignTool) + { + container.MaskContent(); + } + + // Queue a (single) pass to unmask newly visible content on the next tick + if (!_queuedUnmaskVisibleContent) + { + _queuedUnmaskVisibleContent = true; + Dispatcher.BeginInvoke(() => + { + _queuedUnmaskVisibleContent = false; + UnmaskVisibleContent(); + }); + } + } + + private static readonly DependencyProperty VerticalOffsetShadowProperty = + DependencyProperty.Register("VerticalOffsetShadow", typeof(double), typeof(DeferredLoadListBox), new PropertyMetadata(-1.0, OnVerticalOffsetShadowChanged)); + private static void OnVerticalOffsetShadowChanged(DependencyObject o, DependencyPropertyChangedEventArgs e) + { + // Handle ScrollViewer VerticalOffset change by unmasking newly visible content + ((DeferredLoadListBox)o).UnmaskVisibleContent(); + } + + private void UnmaskVisibleContent() + { + // Capture variables + var count = Items.Count; + + // Find index of any container within view using (1-indexed) binary search + var index = -1; + var l = 0; + var r = count + 1; + while (-1 == index) + { + var p = (r - l) / 2; + if (0 == p) + { + break; + } + p += l; + var c = (DeferredLoadListBoxItem)_generator.ContainerFromIndex(p - 1); + if (null == c) + { + if (_inOnApplyTemplate) + { + // Applying template; don't expect to have containers at this point + return; + } + // Should always be able to get the container + var presenter = FindFirstChildOfType(_scrollViewer); + var panel = (null == presenter) ? null : FindFirstChildOfType(presenter); + if (panel is VirtualizingStackPanel) + { + throw new NotSupportedException("Must change ItemsPanel to be a StackPanel (via the ItemsPanel property)."); + } + else + { + throw new NotSupportedException("Couldn't find container for item (ItemsPanel should be a StackPanel)."); + } + } + switch (Overlap(_scrollViewer, c, 0)) + { + case OverlapKind.Overlap: + index = p - 1; + break; + case OverlapKind.ChildAbove: + l = p; + break; + case OverlapKind.ChildBelow: + r = p; + break; + } + } + + if (-1 != index) + { + // Unmask visible items below the current item + for (var i = index; i < count; i++) + { + if (!UnmaskItemContent(i)) + { + break; + } + } + + // Unmask visible items above the current item + for (var i = index - 1; 0 <= i; i--) + { + if (!UnmaskItemContent(i)) + { + break; + } + } + } + } + + private bool UnmaskItemContent(int index) + { + var container = (DeferredLoadListBoxItem)_generator.ContainerFromIndex(index); + if (null != container) + { + // Return quickly if not masked (but periodically check visibility anyway so we can stop once we're out of range) + if (!container.Masked && (0 != (index % 16))) + { + return true; + } + // Check necessary conditions + if (0 == container.ActualHeight) + { + // In some cases, ActualHeight will be 0 here, but can be "fixed" with an explicit call to UpdateLayout + container.UpdateLayout(); + if (0 == container.ActualHeight) + { + throw new NotSupportedException("All containers must have a Height set (ex: via ItemContainerStyle), though the heights do not all need to be the same."); + } + } + // If container overlaps the "visible" area (i.e. on or near the screen), unmask it + if (OverlapKind.Overlap == Overlap(_scrollViewer, container, 2 * _scrollViewer.ActualHeight)) + { + container.UnmaskContent(); + return true; + } + } + return false; + } + + private static bool Overlap(double startA, double endA, double startB, double endB) + { + return (((startA <= startB) && (startB <= endA)) || + ((startB <= startA) && (startA <= endB))); + } + + private static OverlapKind Overlap(ScrollViewer parent, FrameworkElement child, double padding) + { + // Get child transform relative to parent + //var transform = child.TransformToVisual(parent); // Unreliable on Windows Phone 7; throws ArgumentException sometimes + var layoutSlot = LayoutInformation.GetLayoutSlot(child); + var transform = new TranslateTransform { /*X = layoutSlot.Left - parent.HorizontalOffset,*/ Y = layoutSlot.Top - parent.VerticalOffset }; + // Get child bounds relative to parent + var bounds = new Rect(transform.Transform(new Point()), transform.Transform(new Point(/*child.ActualWidth*/ 0, child.ActualHeight))); + // Return kind of overlap + if (Overlap(0 - padding, parent.ActualHeight + padding, bounds.Top, bounds.Bottom)) + { + return OverlapKind.Overlap; + } + else if (bounds.Top < 0) + { + return OverlapKind.ChildAbove; + } + else + { + return OverlapKind.ChildBelow; + } + } + + private static T FindFirstChildOfType(DependencyObject root) where T : class + { + // Enqueue root node + var queue = new Queue(); + queue.Enqueue(root); + while (0 < queue.Count) + { + // Dequeue next node and check its children + var current = queue.Dequeue(); + for (var i = VisualTreeHelper.GetChildrenCount(current) - 1; 0 <= i; i--) + { + var child = VisualTreeHelper.GetChild(current, i); + var typedChild = child as T; + if (null != typedChild) + { + return typedChild; + } + // Enqueue child + queue.Enqueue(child); + } + } + // No children match + return null; + } + } +} diff --git a/Juick/Classes/DeferredLoadListBoxItem.cs b/Juick/Classes/DeferredLoadListBoxItem.cs new file mode 100644 index 0000000..97bfc18 --- /dev/null +++ b/Juick/Classes/DeferredLoadListBoxItem.cs @@ -0,0 +1,45 @@ +// Copyright (C) Microsoft Corporation. All Rights Reserved. +// This code released under the terms of the Microsoft Public License +// (Ms-PL, http://opensource.org/licenses/ms-pl.html). + +using System.Windows; +using System.Windows.Controls; + +namespace Juick.Classes +{ + /// + /// Implements a subclass of ListBoxItem that is used in conjunction with + /// the DeferredLoadListBox to defer the loading of off-screen items. + /// + public class DeferredLoadListBoxItem : ListBoxItem + { + private object _maskedContent; + private DataTemplate _maskedContentTemplate; + + internal bool Masked { get; set; } + + internal void MaskContent() + { + if (!Masked) + { + _maskedContent = Content; + _maskedContentTemplate = ContentTemplate; + Content = null; + ContentTemplate = null; + Masked = true; + } + } + + internal void UnmaskContent() + { + if (Masked) + { + ContentTemplate = _maskedContentTemplate; + Content = _maskedContent; + _maskedContentTemplate = null; + _maskedContent = null; + Masked = false; + } + } + } +} diff --git a/Juick/Classes/LowProfileImageLoader.cs b/Juick/Classes/LowProfileImageLoader.cs new file mode 100644 index 0000000..d1eb3da --- /dev/null +++ b/Juick/Classes/LowProfileImageLoader.cs @@ -0,0 +1,294 @@ +// Copyright (C) Microsoft Corporation. All Rights Reserved. +// This code released under the terms of the Microsoft Public License +// (Ms-PL, http://opensource.org/licenses/ms-pl.html). + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics.CodeAnalysis; +using System.IO; +using System.Net; +using System.Threading; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Media.Imaging; + +namespace Juick.Classes +{ + /// + /// Provides access to the Image.UriSource attached property which allows + /// Images to be loaded by Windows Phone with less impact to the UI thread. + /// + public static class LowProfileImageLoader + { + private const int WorkItemQuantum = 5; + private static readonly Thread _thread = new Thread(WorkerThreadProc); + private static readonly Queue _pendingRequests = new Queue(); + private static readonly Queue _pendingResponses = new Queue(); + private static readonly object _syncBlock = new object(); + private static bool _exiting; + + /// + /// Gets the value of the Uri to use for providing the contents of the Image's Source property. + /// + /// Image needing its Source property set. + /// Uri to use for providing the contents of the Source property. + [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "UriSource is applicable only to Image elements.")] + public static Uri GetUriSource(Image obj) + { + if (null == obj) + { + throw new ArgumentNullException("obj"); + } + return (Uri)obj.GetValue(UriSourceProperty); + } + + /// + /// Sets the value of the Uri to use for providing the contents of the Image's Source property. + /// + /// Image needing its Source property set. + /// Uri to use for providing the contents of the Source property. + [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "UriSource is applicable only to Image elements.")] + public static void SetUriSource(Image obj, Uri value) + { + if (null == obj) + { + throw new ArgumentNullException("obj"); + } + obj.SetValue(UriSourceProperty, value); + } + + /// + /// Identifies the UriSource attached DependencyProperty. + /// + public static readonly DependencyProperty UriSourceProperty = DependencyProperty.RegisterAttached( + "UriSource", typeof(Uri), typeof(LowProfileImageLoader), new PropertyMetadata(OnUriSourceChanged)); + + /// + /// Gets or sets a value indicating whether low-profile image loading is enabled. + /// + public static bool IsEnabled { get; set; } + + [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline", Justification = "Static constructor performs additional tasks.")] + static LowProfileImageLoader() + { + // Start worker thread + _thread.Start(); + Application.Current.Exit += new EventHandler(HandleApplicationExit); + IsEnabled = true; + } + + private static void HandleApplicationExit(object sender, EventArgs e) + { + // Tell worker thread to exit + _exiting = true; + if (Monitor.TryEnter(_syncBlock, 100)) + { + Monitor.Pulse(_syncBlock); + Monitor.Exit(_syncBlock); + } + } + + [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Relevant exceptions don't have a common base class.")] + [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Linear flow is easy to understand.")] + private static void WorkerThreadProc(object unused) + { + Random rand = new Random(); + var pendingRequests = new List(); + var pendingResponses = new Queue(); + while (!_exiting) + { + lock (_syncBlock) + { + // Wait for more work if there's nothing left to do + if ((0 == _pendingRequests.Count) && (0 == _pendingResponses.Count) && (0 == pendingRequests.Count) && (0 == pendingResponses.Count)) + { + Monitor.Wait(_syncBlock); + if (_exiting) + { + return; + } + } + // Copy work items to private collections + while (0 < _pendingRequests.Count) + { + var pendingRequest = _pendingRequests.Dequeue(); + // Search for another pending request for the same Image element + for (var i = 0; i < pendingRequests.Count; i++) + { + if (pendingRequests[i].Image == pendingRequest.Image) + { + // Found one; replace it + pendingRequests[i] = pendingRequest; + pendingRequest = null; + break; + } + } + if (null != pendingRequest) + { + // Unique request; add it + pendingRequests.Add(pendingRequest); + } + } + while (0 < _pendingResponses.Count) + { + pendingResponses.Enqueue(_pendingResponses.Dequeue()); + } + } + Queue pendingCompletions = new Queue(); + // Process pending requests + var count = pendingRequests.Count; + for (var i = 0; (0 < count) && (i < WorkItemQuantum); i++) + { + // Choose a random item to behave reasonably at both extremes (FIFO/FILO) + var index = rand.Next(count); + var pendingRequest = pendingRequests[index]; + pendingRequests[index] = pendingRequests[count - 1]; + pendingRequests.RemoveAt(count - 1); + count--; + if (pendingRequest.Uri.IsAbsoluteUri) + { + // Download from network + var webRequest = HttpWebRequest.CreateHttp(pendingRequest.Uri); + webRequest.AllowReadStreamBuffering = true; // Don't want to block this thread or the UI thread on network access + webRequest.BeginGetResponse(HandleGetResponseResult, new ResponseState(webRequest, pendingRequest.Image, pendingRequest.Uri)); + } + else + { + // Load from application (must have "Build Action"="Content") + var originalUriString = pendingRequest.Uri.OriginalString; + // Trim leading '/' to avoid problems + var resourceStreamUri = originalUriString.StartsWith("/", StringComparison.Ordinal) ? new Uri(originalUriString.TrimStart('/'), UriKind.Relative) : pendingRequest.Uri; + // Enqueue resource stream for completion + var streamResourceInfo = Application.GetResourceStream(resourceStreamUri); + if (null != streamResourceInfo) + { + pendingCompletions.Enqueue(new PendingCompletion(pendingRequest.Image, pendingRequest.Uri, streamResourceInfo.Stream)); + } + } + // Yield to UI thread + Thread.Sleep(1); + } + // Process pending responses + for (var i = 0; (0 < pendingResponses.Count) && (i < WorkItemQuantum); i++) + { + var pendingResponse = pendingResponses.Dequeue(); + var responseState = (ResponseState)pendingResponse.AsyncState; + try + { + var response = responseState.WebRequest.EndGetResponse(pendingResponse); + pendingCompletions.Enqueue(new PendingCompletion(responseState.Image, responseState.Uri, response.GetResponseStream())); + } + catch (WebException) + { + // Ignore web exceptions (ex: not found) + } + // Yield to UI thread + Thread.Sleep(1); + } + // Process pending completions + if (0 < pendingCompletions.Count) + { + // Get the Dispatcher and process everything that needs to happen on the UI thread in one batch + Deployment.Current.Dispatcher.BeginInvoke(() => + { + while (0 < pendingCompletions.Count) + { + // Decode the image and set the source + var pendingCompletion = pendingCompletions.Dequeue(); + if (GetUriSource(pendingCompletion.Image) == pendingCompletion.Uri) + { + var bitmap = new BitmapImage(); + try + { + bitmap.SetSource(pendingCompletion.Stream); + } + catch + { + // Ignore image decode exceptions (ex: invalid image) + } + pendingCompletion.Image.Source = bitmap; + } + else + { + // Uri mis-match; do nothing + } + // Dispose of response stream + pendingCompletion.Stream.Dispose(); + } + }); + } + } + } + + private static void OnUriSourceChanged(DependencyObject o, DependencyPropertyChangedEventArgs e) + { + var image = (Image)o; + var uri = (Uri)e.NewValue; + + if (!IsEnabled || DesignerProperties.IsInDesignTool) + { + // Avoid handing off to the worker thread (can cause problems for design tools) + image.Source = new BitmapImage(uri); + } + else + { + // Clear-out the current image because it's now stale (helps when used with virtualization) + image.Source = null; + lock (_syncBlock) + { + // Enqueue the request + _pendingRequests.Enqueue(new PendingRequest(image, uri)); + Monitor.Pulse(_syncBlock); + } + } + } + + private static void HandleGetResponseResult(IAsyncResult result) + { + lock (_syncBlock) + { + // Enqueue the response + _pendingResponses.Enqueue(result); + Monitor.Pulse(_syncBlock); + } + } + + private class PendingRequest + { + public Image Image { get; private set; } + public Uri Uri { get; private set; } + public PendingRequest(Image image, Uri uri) + { + Image = image; + Uri = uri; + } + } + + private class ResponseState + { + public WebRequest WebRequest { get; private set; } + public Image Image { get; private set; } + public Uri Uri { get; private set; } + public ResponseState(WebRequest webRequest, Image image, Uri uri) + { + WebRequest = webRequest; + Image = image; + Uri = uri; + } + } + + private class PendingCompletion + { + public Image Image { get; private set; } + public Uri Uri { get; private set; } + public Stream Stream { get; private set; } + public PendingCompletion(Image image, Uri uri, Stream stream) + { + Image = image; + Uri = uri; + Stream = stream; + } + } + } +} diff --git a/Juick/Juick.csproj b/Juick/Juick.csproj index 1ae974a..d467f85 100644 --- a/Juick/Juick.csproj +++ b/Juick/Juick.csproj @@ -71,9 +71,12 @@ + + + diff --git a/Juick/MainPage.xaml b/Juick/MainPage.xaml index ded6d33..dfa0c4f 100644 --- a/Juick/MainPage.xaml +++ b/Juick/MainPage.xaml @@ -67,7 +67,7 @@ - + - + - + true prompt 4 + true diff --git a/Juick/Properties/AssemblyInfo.cs b/Juick/Properties/AssemblyInfo.cs index 9a52d9e..9a99ba0 100644 --- a/Juick/Properties/AssemblyInfo.cs +++ b/Juick/Properties/AssemblyInfo.cs @@ -32,6 +32,6 @@ using System.Resources; // // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("1.0.9.9")] -[assembly: AssemblyFileVersion("1.0.9.9")] +[assembly: AssemblyVersion("1.0.9.10")] +[assembly: AssemblyFileVersion("1.0.9.10")] [assembly: NeutralResourcesLanguageAttribute("en-US")] -- cgit v1.2.3 From 6df49ee7c25d739ec6445a13e1aa828a4da41730 Mon Sep 17 00:00:00 2001 From: Vitaly Takmazov Date: Sat, 2 Mar 2013 20:59:42 +0400 Subject: use LowProfileImageLoader also on Attachment --- Juick/MainPage.xaml | 4 ++-- Juick/ThreadView.xaml | 2 +- Juick/ViewModels/MessageListViewModelBase.cs | 4 ++-- Juick/ViewModels/MessageViewModel.cs | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Juick/MainPage.xaml b/Juick/MainPage.xaml index dfa0c4f..013fc34 100644 --- a/Juick/MainPage.xaml +++ b/Juick/MainPage.xaml @@ -80,7 +80,7 @@ Foreground="{StaticResource PhoneForegroundBrush}" Margin="5,0,5,5" VerticalAlignment="Top" IsReadOnly="True" Text="{Binding MessageText}" /> - + - + - +