private async void TranscodeImage_Click(object sender, RoutedEventArgs e)
{
if ((await PhotoCollection[Flip.SelectedIndex].PhotoFile.GetStorageItem().ConfigureAwait(true)) is StorageFile OriginFile)
{
TranscodeImageDialog Dialog = null;
using (IRandomAccessStream OriginStream = await OriginFile.OpenAsync(FileAccessMode.Read))
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(OriginStream);
Dialog = new TranscodeImageDialog(Decoder.PixelWidth, Decoder.PixelHeight);
}
if (await Dialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary)
{
TranscodeLoadingControl.IsLoading = true;
MainPage.ThisPage.IsAnyTaskRunning = true;
await GeneralTransformer.TranscodeFromImageAsync(OriginFile, Dialog.TargetFile, Dialog.IsEnableScale, Dialog.ScaleWidth, Dialog.ScaleHeight, Dialog.InterpolationMode).ConfigureAwait(true);
await Task.Delay(1000).ConfigureAwait(true);
TranscodeLoadingControl.IsLoading = false;
MainPage.ThisPage.IsAnyTaskRunning = false;
}
}
}
private static int DeserializeFile(string workingFilePath)
{
string fileName = Path.GetFileName(workingFilePath);
string serializedData = File.ReadAllText(workingFilePath, Encoding.UTF8);
if (string.IsNullOrEmpty(serializedData))
{
QuickLogger.Warning($"File '{fileName}' contained no text");
return(0);
}
if (EmProperty.CheckKey(serializedData, out string key))
{
int check = -2;
if (PackagesLookup.TryGetValue(key, out IParsingPackage package))
{
check = package.ParseEntries(serializedData, OriginFile.GetOriginFile(fileName));
}
else
{
QuickLogger.Warning($"Unknown primary key '{key}' detected in file '{fileName}'");
return(0);
}
switch (check)
{
case -2:
QuickLogger.Error($"Unexpected error when attempting to parse file '{fileName}'");
break;
case -1:
QuickLogger.Warning($"Unable to parse file '{fileName}'");
break;
case 0:
QuickLogger.Warning($"File '{fileName}' was parsed but no entries were found");
break;
default:
QuickLogger.Debug($"{check} entries parsed from file '{fileName}'");
return(check);
}
}
else
{
QuickLogger.Warning($"Could not identify primary key in file '{fileName}'");
}
return(0);
}
internal void StartUpload()
{
//fill file info to load
FileRepositoryInstance.CurrentOperations = new List <FileRepository.Manager.Models.FileModel>();
FilesToUpload.All(OriginFile =>
{
FileRepositoryInstance.CurrentOperations.Add(
new FileRepository.Manager.Models.FileModel()
{
FilePathLocalSystem = OriginFile,
FilePathRemoteSystem = RemoteFolder.TrimEnd('\\') + "\\" + OriginFile.Substring(OriginFile.LastIndexOf("\\")).TrimStart('\\'),
Operation = FileRepository.Manager.Models.enumOperation.UploadFile
});
return(true);
});
//start load
FileRepositoryInstance.StartOperation(false);
}
private async Task ImportFilesAsync(IEnumerable <StorageFile> FileList)
{
if (FileList.Any())
{
await ActivateLoading(true, DisplayString : Globalization.GetString("Progress_Tip_Importing"));
Cancellation = new CancellationTokenSource();
try
{
ulong TotalSize = 0;
ulong CurrentPosition = 0;
List <FileSystemStorageFile> NewFileList = new List <FileSystemStorageFile>();
foreach (StorageFile ImportFile in FileList)
{
FileSystemStorageFile File = await FileSystemStorageItemBase.CreatedByStorageItemAsync(ImportFile);
if (File != null)
{
NewFileList.Add(File);
TotalSize += File.SizeRaw;
}
}
foreach (FileSystemStorageFile OriginFile in NewFileList)
{
string EncryptedFilePath = Path.Combine(SecureFolder.Path, $"{Path.GetFileNameWithoutExtension(OriginFile.Name)}.sle");
if (await FileSystemStorageItemBase.CreateAsync(EncryptedFilePath, StorageItemTypes.File, CreateOption.GenerateUniqueName) is FileSystemStorageFile EncryptedFile)
{
using (FileStream OriginFStream = await OriginFile.GetFileStreamFromFileAsync(AccessMode.Read))
using (FileStream EncryptFStream = await EncryptedFile.GetFileStreamFromFileAsync(AccessMode.Write))
using (SLEOutputStream SLEStream = new SLEOutputStream(EncryptFStream, OriginFile.Name, AESKey, AESKeySize))
{
await OriginFStream.CopyToAsync(SLEStream, OriginFStream.Length, async (s, e) =>
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
ProBar.IsIndeterminate = false;
ProBar.Value = Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * OriginFile.SizeRaw)) * 100d / TotalSize);
});
}, Cancellation.Token);
CurrentPosition += OriginFile.SizeRaw;
await Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
ProBar.Value = Convert.ToInt32(CurrentPosition * 100d / TotalSize);
});
}
await EncryptedFile.RefreshAsync();
SecureCollection.Add(EncryptedFile);
await OriginFile.DeleteAsync(false);
}
}
}
catch (OperationCanceledException cancelException)
{
LogTracer.Log(cancelException, "Import items to SecureArea have been cancelled");
}
catch (Exception ex)
{
LogTracer.Log(ex, "An exception was threw when importing file");
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_EncryptError_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
_ = await Dialog.ShowAsync();
}
finally
{
Cancellation.Dispose();
Cancellation = null;
await ActivateLoading(false);
}
}
}
