Added support for CSR for URL preview

d2dyno1 · d2dyno1 · commit 6c539f9e0f8f · 2021-08-28T21:48:20.000+02:00
diff --git a/ClipboardCanvas/CanavsPasteModels/BasePasteModel.cs b/ClipboardCanvas/CanavsPasteModels/BasePasteModel.cs
@@ -149,8 +149,8 @@ protected async Task<SafeWrapperResult> SaveDataToFileInternal()
             if (IsContentAsReference && await sourceItem == null)
             {
                 // We need to update the reference file because the one we created is empty
-                ReferenceFile referenceFile = await ReferenceFile.GetFile(associatedFile);
-                return await referenceFile.UpdateReference(new ReferenceFileData(_pastedItem.Path));
+                ReferenceFile referenceFile = await ReferenceFile.GetReferenceFile(associatedFile);
+                return await referenceFile.UpdateReference(_pastedItem.Path);
             } 
             else
             {
diff --git a/ClipboardCanvas/DataModels/CanvasItem.cs b/ClipboardCanvas/DataModels/CanvasItem.cs
@@ -48,7 +48,7 @@ protected virtual async Task<IStorageItem> GetSourceItem()
 
             if (AssociatedItem is StorageFile file && ReferenceFile.IsReferenceFile(file))
             {
-                ReferenceFile referenceFile = await ReferenceFile.GetFile(file);
+                ReferenceFile referenceFile = await ReferenceFile.GetReferenceFile(file);
                 sourceItem = referenceFile.ReferencedItem;
             }
             else
diff --git a/ClipboardCanvas/DataModels/ContentDataModels/BaseContentTypeModel.cs b/ClipboardCanvas/DataModels/ContentDataModels/BaseContentTypeModel.cs
@@ -85,7 +85,7 @@ public static async Task<BaseContentTypeModel> GetContentType(IStorageItem item,
                 if (ReferenceFile.IsReferenceFile(file))
                 {
                     // Reference File, get the destination file extension
-                    ReferenceFile referenceFile = await ReferenceFile.GetFile(file);
+                    ReferenceFile referenceFile = await ReferenceFile.GetReferenceFile(file);
 
                     if (referenceFile.ReferencedItem == null)
                     {
diff --git a/ClipboardCanvas/Helpers/SafetyHelpers/SafeWrapperResult.cs b/ClipboardCanvas/Helpers/SafetyHelpers/SafeWrapperResult.cs
@@ -50,19 +50,22 @@ public static SafeWrapperResult FromException(Exception exception, ISafeWrapperE
             return exceptionReporter.GetStatusResult(exception);
         }
 
-        public static implicit operator OperationErrorCode(SafeWrapperResult wrapperResult) => wrapperResult?.Details?.errorCode ?? OperationErrorCode.InvalidArgument;
+        public static implicit operator OperationErrorCode(SafeWrapperResult wrapperResult)
+            => wrapperResult?.Details?.errorCode ?? OperationErrorCode.InvalidArgument;
 
-        public static implicit operator bool(SafeWrapperResult wrapperResult) => wrapperResult?.Details?.errorCode == OperationErrorCode.Success;
+        public static implicit operator bool(SafeWrapperResult wrapperResult)
+            => (wrapperResult?.Details?.errorCode ?? OperationErrorCode.UnknownFailed) == OperationErrorCode.Success;
 
-        public static implicit operator SafeWrapperResult(SafeWrapperResultDetails details) => new SafeWrapperResult(details);
+        public static implicit operator SafeWrapperResult(SafeWrapperResultDetails details)
+            => new SafeWrapperResult(details);
 
         public static implicit operator SafeWrapperResult((OperationErrorCode errorCode, Exception innerException) details)
-            => new SafeWrapperResultDetails(details.errorCode, details.innerException);
+            => new SafeWrapperResult(details.errorCode, details.innerException);
 
         public static implicit operator SafeWrapperResult((OperationErrorCode errorCode, string message) details)
-            => new SafeWrapperResultDetails(details.errorCode, details.message);
+            => new SafeWrapperResult(details.errorCode, details.message);
 
         public static implicit operator SafeWrapperResult((OperationErrorCode errorCode, Exception innerException, string message) details)
-            => new SafeWrapperResultDetails(details.errorCode, details.innerException, details.message);
+            => new SafeWrapperResult(details.errorCode, details.innerException, details.message);
     }
 }
diff --git a/ClipboardCanvas/Helpers/WebHelpers.cs b/ClipboardCanvas/Helpers/WebHelpers.cs
@@ -30,9 +30,9 @@ public static bool IsUrl(string str)
 
         public static bool IsUrlFile(string url)
         {
-            if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri) && (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps))
+            if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri) && (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps) && uri.IsFile)
             {
-                return Path.HasExtension(url);
+                return true;
             }
 
             return false;
@@ -45,7 +45,7 @@ public static async Task<bool> IsValidUrl(string url)
                 return false;
             }
 
-            WebResponse response;
+            WebResponse response = null;
             try
             {
                 WebRequest request = WebRequest.Create(url);
@@ -66,6 +66,10 @@ public static async Task<bool> IsValidUrl(string url)
             {
                 return false;
             }
+            finally
+            {
+                response?.Dispose();
+            }
 
             return true;
         }
@@ -207,7 +211,7 @@ public static async Task<string> FormatImageUrl(string rawImageUrl, string url)
             if (!string.IsNullOrEmpty(rawImageUrl))
             {
                 string formattedUrl;
-
+                
                 if (!rawImageUrl.Contains("http"))
                 {
                     string baseUrl;
@@ -223,15 +227,24 @@ public static async Task<string> FormatImageUrl(string rawImageUrl, string url)
                             http = "http://";
                         }
 
-                        var uri = new Uri(url);
-                        baseUrl = $"{http}{uri.Host}";
+                        Uri rawImageUri = new Uri(rawImageUrl);
+                        if (!string.IsNullOrEmpty(rawImageUri.Host))
+                        {
+                            baseUrl = $"{http}{rawImageUri.Host}";
+                            rawImageUrl = rawImageUrl.Replace(rawImageUri.Host, string.Empty);
+                        }
+                        else
+                        {
+                            Uri uri = new Uri(url);
+                            baseUrl = $"{http}{uri.Host}";
+                        }
                     }
                     else
                     {
                         baseUrl = url;
                     }
 
-                    formattedUrl = ($"{baseUrl}/{rawImageUrl}").PreventNull(string.Empty).Replace("///", "/").Replace("//", "/").Replace("https:/", "https://");
+                    formattedUrl = ($"{baseUrl}/{rawImageUrl}").PreventNull(string.Empty).Replace("///", "/").Replace("//", "/").Replace(":/", "://");
                 }
                 else
                 {
diff --git a/ClipboardCanvas/Pages/HomePage.xaml.cs b/ClipboardCanvas/Pages/HomePage.xaml.cs
@@ -2,6 +2,8 @@
 using Windows.UI.Xaml.Navigation;
 
 using ClipboardCanvas.ViewModels.Pages;
+using ClipboardCanvas.ViewModels.Widgets.Timeline;
+using System.Threading;
 
 // The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=234238
 
@@ -20,6 +22,10 @@ public HomePageViewModel ViewModel
 
         protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
         {
+            TimelineWidgetViewModel.LoadCancellationToken.Cancel();
+            TimelineWidgetViewModel.LoadCancellationToken.Dispose();
+            TimelineWidgetViewModel.LoadCancellationToken = new CancellationTokenSource();
+
             CollectionsWidget.ViewModel.Dispose();
             this.ViewModel.Dispose();
 
diff --git a/ClipboardCanvas/ReferenceItems/ReferenceFile.cs b/ClipboardCanvas/ReferenceItems/ReferenceFile.cs
@@ -1,12 +1,13 @@
-﻿using ClipboardCanvas.Enums;
+﻿using Newtonsoft.Json;
+using System.IO;
+using System.Threading.Tasks;
+using Windows.Storage;
+
+using ClipboardCanvas.Enums;
 using ClipboardCanvas.Exceptions;
 using ClipboardCanvas.Helpers.Filesystem;
 using ClipboardCanvas.Helpers.SafetyHelpers;
-using Newtonsoft.Json;
 using System;
-using System.IO;
-using System.Threading.Tasks;
-using Windows.Storage;
 
 namespace ClipboardCanvas.ReferenceItems
 {
@@ -17,47 +18,46 @@ public sealed class ReferenceFile
     {
         private readonly StorageFile _innerReferenceFile;
 
+        private ReferenceFileData _referenceFileData;
+
         public SafeWrapperResult LastError { get; private set; } = SafeWrapperResult.SUCCESS;
 
         public IStorageItem ReferencedItem { get; private set; }
 
-        public ReferenceFileData ReferenceFileData { get; private set; }
-
         private ReferenceFile(StorageFile innerFile, IStorageItem referencedItem)
         {
             this._innerReferenceFile = innerFile;
             this.ReferencedItem = referencedItem;
         }
 
-        public async Task<SafeWrapperResult> UpdateReference(ReferenceFileData referenceFileData)
+        public async Task<SafeWrapperResult> UpdateReference(string newPath)
         {
-            string serialized = JsonConvert.SerializeObject(referenceFileData, Formatting.Indented);
-            SafeWrapperResult result = await FilesystemOperations.WriteFileText(_innerReferenceFile, serialized);
+            _referenceFileData = new ReferenceFileData(newPath);
+            string serialized = JsonConvert.SerializeObject(_referenceFileData, Formatting.Indented);
 
-            return result;
+            return await FilesystemOperations.WriteFileText(_innerReferenceFile, serialized);
         }
 
         private static async Task<SafeWrapper<ReferenceFileData>> ReadData(StorageFile referenceFile)
         {
             SafeWrapper<string> data = await FilesystemOperations.ReadFileText(referenceFile);
-
             if (!data)
             {
-                return new SafeWrapper<ReferenceFileData>(null, data.Details);
+                return (null, data.Details);
             }
 
             ReferenceFileData referenceFileData = JsonConvert.DeserializeObject<ReferenceFileData>(data);
-
-            return new SafeWrapper<ReferenceFileData>(referenceFileData, SafeWrapperResult.SUCCESS);
+            return (referenceFileData, SafeWrapperResult.SUCCESS);
         }
 
-        public static async Task<ReferenceFile> GetFile(StorageFile referenceFile)
+        public static async Task<ReferenceFile> GetReferenceFile(StorageFile referenceFile)
         {
             // The file is not a Reference File
             if (!IsReferenceFile(referenceFile))
             {
                 return null;
             }
+
             // The file does not exist
             if (!StorageHelpers.Existsh(referenceFile.Path))
             {
@@ -74,13 +74,20 @@ public static async Task<ReferenceFile> GetFile(StorageFile referenceFile)
 
         private static async Task<ReferenceFile> GetFile(StorageFile referenceFile, SafeWrapper<ReferenceFileData> referenceFileData)
         {
-            if (!referenceFileData || string.IsNullOrEmpty(referenceFileData.Result?.path))
+            if (!referenceFileData)
             {
                 return new ReferenceFile(referenceFile, null)
                 {
                     LastError = referenceFileData
                 };
             }
+            else if (string.IsNullOrEmpty(referenceFileData?.Result?.path))
+            {
+                return new ReferenceFile(referenceFile, null)
+                {
+                    LastError = new SafeWrapperResult(OperationErrorCode.InvalidArgument, new NullReferenceException(), "Reference File path is null.")
+                };
+            }
 
             SafeWrapper<IStorageItem> file = await StorageHelpers.ToStorageItemWithError<IStorageItem>(referenceFileData.Result.path);
 
@@ -98,12 +105,15 @@ private static async Task<ReferenceFile> GetFile(StorageFile referenceFile, Safe
                 {
                     return new ReferenceFile(referenceFile, null)
                     {
-                        LastError = (SafeWrapperResult)file
+                        LastError = file
                     };
                 }
             }
 
-            return new ReferenceFile(referenceFile, file.Result);
+            return new ReferenceFile(referenceFile, file.Result)
+            {
+                _referenceFileData = referenceFileData.Result
+            };
         }
 
         public static bool IsReferenceFile(StorageFile file)
diff --git a/ClipboardCanvas/Services/Implementation/TimelineService.cs b/ClipboardCanvas/Services/Implementation/TimelineService.cs
@@ -1,4 +1,5 @@
-﻿using System.Threading.Tasks;
+﻿using System.Collections.Generic;
+using System.Threading.Tasks;
 
 using ClipboardCanvas.DataModels;
 using ClipboardCanvas.Models;
@@ -41,10 +42,13 @@ public async Task LoadSectionAsync(TimelineSectionViewModel timelineSection)
                 return;
             }
 
+            List<Task> loadItemTasks = new List<Task>();
             foreach (var item in timelineSection.Items)
             {
-                await item.InitializeSectionItemContent();
+                loadItemTasks.Add(item.InitializeSectionItemContent());
             }
+
+            await Task.WhenAll(loadItemTasks);
         }
 
         public async Task LoadAllSectionsAsync()
@@ -54,10 +58,13 @@ public async Task LoadAllSectionsAsync()
                 return;
             }
 
+            List<Task> loadItemTasks = new List<Task>();
             foreach (var item in TimelineWidgetViewModel.Sections)
             {
-                await LoadSectionAsync(item);
+                loadItemTasks.Add(LoadSectionAsync(item));
             }
+
+            await Task.WhenAll(loadItemTasks);
         }
 
         public void UnloadSection(TimelineSectionViewModel timelineSection)
diff --git a/ClipboardCanvas/UserControls/InteractableCanvasControl.xaml b/ClipboardCanvas/UserControls/InteractableCanvasControl.xaml
@@ -90,8 +90,8 @@
                                 x:Name="PastedAsReferenceButton"
                                 Grid.Row="1"
                                 Grid.Column="0"
-                                Width="30"
-                                Height="30"
+                                Width="32"
+                                Height="32"
                                 Margin="0,0,0,-4"
                                 Padding="0"
                                 HorizontalAlignment="Left"
diff --git a/ClipboardCanvas/UserControls/InteractableCanvasControl.xaml.cs b/ClipboardCanvas/UserControls/InteractableCanvasControl.xaml.cs
@@ -92,7 +92,7 @@ private void Canvas_Drop(object sender, DragEventArgs e)
                 element.Opacity = 1.0d;
 
                 // Update the ZIndex of the element - set it on top
-                SetOnTop(container);
+                SetOnTop(container); // TODO: Fix this - sometimes other item can shown higher
 
                 this.ViewModel.ItemRearranged();
             }
diff --git a/ClipboardCanvas/UserControls/SimpleCanvasDisplay/UrlSimpleCanvasControl.xaml b/ClipboardCanvas/UserControls/SimpleCanvasDisplay/UrlSimpleCanvasControl.xaml
@@ -25,7 +25,7 @@
             <!--  Header (Icon + Title)  -->
             <RowDefinition Height="Auto" />
             <!--  Content  -->
-            <RowDefinition />
+            <RowDefinition Height="Auto" />
         </Grid.RowDefinitions>
 
         <!--  Header  -->
@@ -103,23 +103,34 @@
                 <tuc:UniformGrid
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch"
-                    CornerRadius="4">
+                    tuc:UniformGrid.AutoLayout="False"
+                    ColumnSpacing="4"
+                    CornerRadius="4"
+                    RowSpacing="4">
                     <Image
                         x:Name="Img1"
+                        VerticalAlignment="Stretch"
                         x:Load="{x:Bind ViewModel.ContentImage1, Mode=OneWay, Converter={StaticResource NullToBooleanConverter}}"
-                        Source="{x:Bind ViewModel.ContentImage1, Mode=OneWay}" />
+                        Source="{x:Bind ViewModel.ContentImage1, Mode=OneWay}"
+                        Stretch="UniformToFill" />
                     <Image
                         x:Name="Img2"
+                        VerticalAlignment="Stretch"
                         x:Load="{x:Bind ViewModel.ContentImage2, Mode=OneWay, Converter={StaticResource NullToBooleanConverter}}"
-                        Source="{x:Bind ViewModel.ContentImage2, Mode=OneWay}" />
+                        Source="{x:Bind ViewModel.ContentImage2, Mode=OneWay}"
+                        Stretch="UniformToFill" />
                     <Image
                         x:Name="Img3"
+                        VerticalAlignment="Stretch"
                         x:Load="{x:Bind ViewModel.ContentImage3, Mode=OneWay, Converter={StaticResource NullToBooleanConverter}}"
-                        Source="{x:Bind ViewModel.ContentImage3, Mode=OneWay}" />
+                        Source="{x:Bind ViewModel.ContentImage3, Mode=OneWay}"
+                        Stretch="UniformToFill" />
                     <Image
                         x:Name="Img4"
+                        VerticalAlignment="Stretch"
                         x:Load="{x:Bind ViewModel.ContentImage4, Mode=OneWay, Converter={StaticResource NullToBooleanConverter}}"
-                        Source="{x:Bind ViewModel.ContentImage4, Mode=OneWay}" />
+                        Source="{x:Bind ViewModel.ContentImage4, Mode=OneWay}"
+                        Stretch="UniformToFill" />
                 </tuc:UniformGrid>
             </Grid>
 
diff --git a/ClipboardCanvas/ViewModels/CollectionPreviewItemViewModel.cs b/ClipboardCanvas/ViewModels/CollectionPreviewItemViewModel.cs
@@ -142,6 +142,7 @@ public async Task UpdateDisplayName()
 
         public void Dispose()
         {
+            _cancellationTokenSource?.Cancel();
             _cancellationTokenSource?.Dispose();
             ReadOnlyCanvasPreviewModel?.Dispose();
             
diff --git a/ClipboardCanvas/ViewModels/UserControls/CanvasDisplay/InfiniteCanvasViewModel.cs b/ClipboardCanvas/ViewModels/UserControls/CanvasDisplay/InfiniteCanvasViewModel.cs
@@ -122,7 +122,6 @@ public override async Task<SafeWrapperResult> TryPasteData(DataPackageView dataP
             }
             else
             {
-
                 // Get correct IPasteModel from contentType
                 IPasteModel canvasPasteModel = CanvasHelpers.GetPasteModelFromContentType(pastedItemContentType, _infiniteCanvasFileReceiver, new StatusCenterOperationReceiver());
 
diff --git a/ClipboardCanvas/ViewModels/UserControls/DisplayControlViewModel.cs b/ClipboardCanvas/ViewModels/UserControls/DisplayControlViewModel.cs
diff --git a/ClipboardCanvas/ViewModels/UserControls/SimpleCanvasDisplay/UrlSimpleCanvasViewModel.cs b/ClipboardCanvas/ViewModels/UserControls/SimpleCanvasDisplay/UrlSimpleCanvasViewModel.cs

Original file line number	Diff line number	Diff line change
`@@ -149,8 +149,8 @@ protected async Task<SafeWrapperResult> SaveDataToFileInternal()`
`149`	`149`	`if (IsContentAsReference && await sourceItem == null)`
`150`	`150`	`{`
`151`	`151`	`// We need to update the reference file because the one we created is empty`
`152`		`- ReferenceFile referenceFile = await ReferenceFile.GetFile(associatedFile);`
`153`		`- return await referenceFile.UpdateReference(new ReferenceFileData(_pastedItem.Path));`
	`152`	`+ ReferenceFile referenceFile = await ReferenceFile.GetReferenceFile(associatedFile);`
	`153`	`+ return await referenceFile.UpdateReference(_pastedItem.Path);`
`154`	`154`	`}`
`155`	`155`	`else`
`156`	`156`	`{`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ protected virtual async Task<IStorageItem> GetSourceItem()`
`48`	`48`
`49`	`49`	`if (AssociatedItem is StorageFile file && ReferenceFile.IsReferenceFile(file))`
`50`	`50`	`{`
`51`		`- ReferenceFile referenceFile = await ReferenceFile.GetFile(file);`
	`51`	`+ ReferenceFile referenceFile = await ReferenceFile.GetReferenceFile(file);`
`52`	`52`	`sourceItem = referenceFile.ReferencedItem;`
`53`	`53`	`}`
`54`	`54`	`else`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public static async Task<BaseContentTypeModel> GetContentType(IStorageItem item,`
`85`	`85`	`if (ReferenceFile.IsReferenceFile(file))`
`86`	`86`	`{`
`87`	`87`	`// Reference File, get the destination file extension`
`88`		`- ReferenceFile referenceFile = await ReferenceFile.GetFile(file);`
	`88`	`+ ReferenceFile referenceFile = await ReferenceFile.GetReferenceFile(file);`
`89`	`89`
`90`	`90`	`if (referenceFile.ReferencedItem == null)`
`91`	`91`	`{`
Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,9 @@ public static bool IsUrl(string str)`
`30`	`30`
`31`	`31`	`public static bool IsUrlFile(string url)`
`32`	`32`	`{`
`33`		`- if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri) && (uri.Scheme == Uri.UriSchemeHttp \|\| uri.Scheme == Uri.UriSchemeHttps))`
	`33`	`+ if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri) && (uri.Scheme == Uri.UriSchemeHttp \|\| uri.Scheme == Uri.UriSchemeHttps) && uri.IsFile)`
`34`	`34`	`{`
`35`		`- return Path.HasExtension(url);`
	`35`	`+ return true;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`return false;`
`@@ -45,7 +45,7 @@ public static async Task<bool> IsValidUrl(string url)`
`45`	`45`	`return false;`
`46`	`46`	`}`
`47`	`47`
`48`		`- WebResponse response;`
	`48`	`+ WebResponse response = null;`
`49`	`49`	`try`
`50`	`50`	`{`
`51`	`51`	`WebRequest request = WebRequest.Create(url);`
`@@ -66,6 +66,10 @@ public static async Task<bool> IsValidUrl(string url)`
`66`	`66`	`{`
`67`	`67`	`return false;`
`68`	`68`	`}`
	`69`	`+ finally`
	`70`	`+ {`
	`71`	`+ response?.Dispose();`
	`72`	`+ }`
`69`	`73`
`70`	`74`	`return true;`
`71`	`75`	`}`
`@@ -207,7 +211,7 @@ public static async Task<string> FormatImageUrl(string rawImageUrl, string url)`
`207`	`211`	`if (!string.IsNullOrEmpty(rawImageUrl))`
`208`	`212`	`{`
`209`	`213`	`string formattedUrl;`
`210`		`-`
	`214`	`+`
`211`	`215`	`if (!rawImageUrl.Contains("http"))`
`212`	`216`	`{`
`213`	`217`	`string baseUrl;`
`@@ -223,15 +227,24 @@ public static async Task<string> FormatImageUrl(string rawImageUrl, string url)`
`223`	`227`	`http = "http://";`
`224`	`228`	`}`
`225`	`229`
`226`		`- var uri = new Uri(url);`
`227`		`- baseUrl = $"{http}{uri.Host}";`
	`230`	`+ Uri rawImageUri = new Uri(rawImageUrl);`
	`231`	`+ if (!string.IsNullOrEmpty(rawImageUri.Host))`
	`232`	`+ {`
	`233`	`+ baseUrl = $"{http}{rawImageUri.Host}";`
	`234`	`+ rawImageUrl = rawImageUrl.Replace(rawImageUri.Host, string.Empty);`
	`235`	`+ }`
	`236`	`+ else`
	`237`	`+ {`
	`238`	`+ Uri uri = new Uri(url);`
	`239`	`+ baseUrl = $"{http}{uri.Host}";`
	`240`	`+ }`
`228`	`241`	`}`
`229`	`242`	`else`
`230`	`243`	`{`
`231`	`244`	`baseUrl = url;`
`232`	`245`	`}`
`233`	`246`
`234`		`- formattedUrl = ($"{baseUrl}/{rawImageUrl}").PreventNull(string.Empty).Replace("///", "/").Replace("//", "/").Replace("https:/", "https://");`
	`247`	`+ formattedUrl = ($"{baseUrl}/{rawImageUrl}").PreventNull(string.Empty).Replace("///", "/").Replace("//", "/").Replace(":/", "://");`
`235`	`248`	`}`
`236`	`249`	`else`
`237`	`250`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,13 @@`
`1`		`-using ClipboardCanvas.Enums;`
	`1`	`+using Newtonsoft.Json;`
	`2`	`+using System.IO;`
	`3`	`+using System.Threading.Tasks;`
	`4`	`+using Windows.Storage;`
	`5`	`+`
	`6`	`+using ClipboardCanvas.Enums;`
`2`	`7`	`using ClipboardCanvas.Exceptions;`
`3`	`8`	`using ClipboardCanvas.Helpers.Filesystem;`
`4`	`9`	`using ClipboardCanvas.Helpers.SafetyHelpers;`
`5`		`-using Newtonsoft.Json;`
`6`	`10`	`using System;`
`7`		`-using System.IO;`
`8`		`-using System.Threading.Tasks;`
`9`		`-using Windows.Storage;`
`10`	`11`
`11`	`12`	`namespace ClipboardCanvas.ReferenceItems`
`12`	`13`	`{`
`@@ -17,47 +18,46 @@ public sealed class ReferenceFile`
`17`	`18`	`{`
`18`	`19`	`private readonly StorageFile _innerReferenceFile;`
`19`	`20`
	`21`	`+ private ReferenceFileData _referenceFileData;`
	`22`	`+`
`20`	`23`	`public SafeWrapperResult LastError { get; private set; } = SafeWrapperResult.SUCCESS;`
`21`	`24`
`22`	`25`	`public IStorageItem ReferencedItem { get; private set; }`
`23`	`26`
`24`		`- public ReferenceFileData ReferenceFileData { get; private set; }`
`25`		`-`
`26`	`27`	`private ReferenceFile(StorageFile innerFile, IStorageItem referencedItem)`
`27`	`28`	`{`
`28`	`29`	`this._innerReferenceFile = innerFile;`
`29`	`30`	`this.ReferencedItem = referencedItem;`
`30`	`31`	`}`
`31`	`32`
`32`		`- public async Task<SafeWrapperResult> UpdateReference(ReferenceFileData referenceFileData)`
	`33`	`+ public async Task<SafeWrapperResult> UpdateReference(string newPath)`
`33`	`34`	`{`
`34`		`- string serialized = JsonConvert.SerializeObject(referenceFileData, Formatting.Indented);`
`35`		`- SafeWrapperResult result = await FilesystemOperations.WriteFileText(_innerReferenceFile, serialized);`
	`35`	`+ _referenceFileData = new ReferenceFileData(newPath);`
	`36`	`+ string serialized = JsonConvert.SerializeObject(_referenceFileData, Formatting.Indented);`
`36`	`37`
`37`		`- return result;`
	`38`	`+ return await FilesystemOperations.WriteFileText(_innerReferenceFile, serialized);`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`private static async Task<SafeWrapper<ReferenceFileData>> ReadData(StorageFile referenceFile)`
`41`	`42`	`{`
`42`	`43`	`SafeWrapper<string> data = await FilesystemOperations.ReadFileText(referenceFile);`
`43`		`-`
`44`	`44`	`if (!data)`
`45`	`45`	`{`
`46`		`- return new SafeWrapper<ReferenceFileData>(null, data.Details);`
	`46`	`+ return (null, data.Details);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`ReferenceFileData referenceFileData = JsonConvert.DeserializeObject<ReferenceFileData>(data);`
`50`		`-`
`51`		`- return new SafeWrapper<ReferenceFileData>(referenceFileData, SafeWrapperResult.SUCCESS);`
	`50`	`+ return (referenceFileData, SafeWrapperResult.SUCCESS);`
`52`	`51`	`}`
`53`	`52`
`54`		`- public static async Task<ReferenceFile> GetFile(StorageFile referenceFile)`
	`53`	`+ public static async Task<ReferenceFile> GetReferenceFile(StorageFile referenceFile)`
`55`	`54`	`{`
`56`	`55`	`// The file is not a Reference File`
`57`	`56`	`if (!IsReferenceFile(referenceFile))`
`58`	`57`	`{`
`59`	`58`	`return null;`
`60`	`59`	`}`
	`60`	`+`
`61`	`61`	`// The file does not exist`
`62`	`62`	`if (!StorageHelpers.Existsh(referenceFile.Path))`
`63`	`63`	`{`
`@@ -74,13 +74,20 @@ public static async Task<ReferenceFile> GetFile(StorageFile referenceFile)`
`74`	`74`
`75`	`75`	`private static async Task<ReferenceFile> GetFile(StorageFile referenceFile, SafeWrapper<ReferenceFileData> referenceFileData)`
`76`	`76`	`{`
`77`		`- if (!referenceFileData \|\| string.IsNullOrEmpty(referenceFileData.Result?.path))`
	`77`	`+ if (!referenceFileData)`
`78`	`78`	`{`
`79`	`79`	`return new ReferenceFile(referenceFile, null)`
`80`	`80`	`{`
`81`	`81`	`LastError = referenceFileData`
`82`	`82`	`};`
`83`	`83`	`}`
	`84`	`+ else if (string.IsNullOrEmpty(referenceFileData?.Result?.path))`
	`85`	`+ {`
	`86`	`+ return new ReferenceFile(referenceFile, null)`
	`87`	`+ {`
	`88`	`+ LastError = new SafeWrapperResult(OperationErrorCode.InvalidArgument, new NullReferenceException(), "Reference File path is null.")`
	`89`	`+ };`
	`90`	`+ }`
`84`	`91`
`85`	`92`	`SafeWrapper<IStorageItem> file = await StorageHelpers.ToStorageItemWithError<IStorageItem>(referenceFileData.Result.path);`
`86`	`93`
`@@ -98,12 +105,15 @@ private static async Task<ReferenceFile> GetFile(StorageFile referenceFile, Safe`
`98`	`105`	`{`
`99`	`106`	`return new ReferenceFile(referenceFile, null)`
`100`	`107`	`{`
`101`		`- LastError = (SafeWrapperResult)file`
	`108`	`+ LastError = file`
`102`	`109`	`};`
`103`	`110`	`}`
`104`	`111`	`}`
`105`	`112`
`106`		`- return new ReferenceFile(referenceFile, file.Result);`
	`113`	`+ return new ReferenceFile(referenceFile, file.Result)`
	`114`	`+ {`
	`115`	`+ _referenceFileData = referenceFileData.Result`
	`116`	`+ };`
`107`	`117`	`}`
`108`	`118`
`109`	`119`	`public static bool IsReferenceFile(StorageFile file)`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Threading.Tasks;`
	`1`	`+using System.Collections.Generic;`
	`2`	`+using System.Threading.Tasks;`
`2`	`3`
`3`	`4`	`using ClipboardCanvas.DataModels;`
`4`	`5`	`using ClipboardCanvas.Models;`
`@@ -41,10 +42,13 @@ public async Task LoadSectionAsync(TimelineSectionViewModel timelineSection)`
`41`	`42`	`return;`
`42`	`43`	`}`
`43`	`44`
	`45`	`+ List<Task> loadItemTasks = new List<Task>();`
`44`	`46`	`foreach (var item in timelineSection.Items)`
`45`	`47`	`{`
`46`		`- await item.InitializeSectionItemContent();`
	`48`	`+ loadItemTasks.Add(item.InitializeSectionItemContent());`
`47`	`49`	`}`
	`50`	`+`
	`51`	`+ await Task.WhenAll(loadItemTasks);`
`48`	`52`	`}`
`49`	`53`
`50`	`54`	`public async Task LoadAllSectionsAsync()`
`@@ -54,10 +58,13 @@ public async Task LoadAllSectionsAsync()`
`54`	`58`	`return;`
`55`	`59`	`}`
`56`	`60`
	`61`	`+ List<Task> loadItemTasks = new List<Task>();`
`57`	`62`	`foreach (var item in TimelineWidgetViewModel.Sections)`
`58`	`63`	`{`
`59`		`- await LoadSectionAsync(item);`
	`64`	`+ loadItemTasks.Add(LoadSectionAsync(item));`
`60`	`65`	`}`
	`66`	`+`
	`67`	`+ await Task.WhenAll(loadItemTasks);`
`61`	`68`	`}`
`62`	`69`
`63`	`70`	`public void UnloadSection(TimelineSectionViewModel timelineSection)`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ private void Canvas_Drop(object sender, DragEventArgs e)`
`92`	`92`	`element.Opacity = 1.0d;`
`93`	`93`
`94`	`94`	`// Update the ZIndex of the element - set it on top`
`95`		`- SetOnTop(container);`
	`95`	`+ SetOnTop(container); // TODO: Fix this - sometimes other item can shown higher`
`96`	`96`
`97`	`97`	`this.ViewModel.ItemRearranged();`
`98`	`98`	`}`