private void du_onStateFileNameDecide(object sender, StateFileNameDecideEventArgs e)
{
IProgressable d = (IProgressable)sender;
OperationInfo op = (OperationInfo)d.State;
op.sliceFileName = e.SliceFileName;
}
public static ProgressWindow CreateAndShowDialog(IProgressable progressable)
{
ProgressWindow window = new ProgressWindow(progressable);
//window.Progress.Completed += (sender, args) => window.Dispatcher.Invoke(() => window.Hide());
window.Show();
return(window);
}
public ProgressWindow(string title, IProgressable progressable)
{
InitializeComponent();
new DraggableWindow(this);
titleTextBlock.Text = title;
progressable.ProgressChanged += Progressable_ProgressChanged;
progressable.Completed += (s, e) => Dispatcher.Invoke(Close);
}
/// <summary>
/// Constructs the popup window.
/// </summary>
public ProgressPopup(IProgressable model)
: this()
{
_model = model;
_model.Progress += model_Progress;
_model.Finished += model_Finished;
}
public ProgressWindow(string title, IProgressable progressable)
{
InitializeComponent();
new DraggableWindow(this);
titleTextBlock.Text = title;
progressable.ProgressChanged += Progressable_ProgressChanged;
progressable.Completed += (s, e) => Dispatcher.Invoke(Close);
}
private void du_onThreadChanged(object sender, ThreadCountChangedEventArgs e)
{
IProgressable d = (IProgressable)sender;
OperationInfo op = (OperationInfo)d.State;
op.runningThreadCount = e.RunningThreadCount;
op.totalThreadCount = e.TotalThreadCount;
fireOnThreadChanged(op);
}
public SplashScreen(IProgressable contentToLoad)
{
InitializeComponent();
contentToLoad.ItemLoaded += OnItemLoaded;
PhraseLoadingProgress.Maximum = contentToLoad.TotalItems;
TotalAssets.Text = contentToLoad.TotalItems.ToString();
Asset.Text = "0";
}
public ProgressToken(IProgressable prograssable)
{
Progressable = prograssable;
if (Progressable != null)
{
Progressable.Progress = 0;
CancellationTokenSource = new CancellationTokenSource
{
};
CancellationToken = CancellationTokenSource.Token;
}
}
internal void InitProgressable(IProgressable progressable)
{
Progressable = progressable;
progressable.ProgressChangedEvent += Progressable_ProgressChangedEvent;
Timer = new Timer
{
Interval = 100,
Enabled = true,
};
StartTime = DateTime.Now;
Timer.AutoReset = true;
Timer.Start();
}
public void RemoveProgressable(IProgressable progressable)
{
int timeRequired = progressable.Setup();
foreach (TickTimer timer in timers)
{
if (timer.TotalTicksToCall == timeRequired)
{
timer.Remove(ref progressable);
break;
}
}
}
public void InitProgressable(IProgressable progress)
{
ProgressViewModel.InitProgressable(progress);
CancelButton.Click += (sender, e) =>
{
if (!progress.IsCompleted)
{
progress.Cancel();
}
};
Closed += (sender, e) =>
{
if (!progress.IsCompleted)
{
progress.Cancel();
}
};
}
public void SetData(IProgressable progressable)
{
if (progressable.IsAbortable)
{
MinimumSize = new Size(350, 125);
MaximumSize = new Size(350, 125);
button_Abort.Visible = true;
}
else
{
MinimumSize = new Size(350, 100);
MaximumSize = new Size(350, 100);
button_Abort.Visible = false;
}
m_progressable = progressable;
progressable.Finished += Progressable_Finished;
progressable.DescriptionChanged += Progressable_DescriptionChanged;
progressable.ProgressChanged += Progressable_ProgressChanged;
progressable.Error += Progressable_Error;
}
private static void Run <T>(IProgressable progress) where T : IProgressView
{
IProgressView view = new ProgressView();
view.InitProgressable(progress);
view.StartShow(() =>
{
try
{
Application.DoEvents();
progress.Start();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
view.EndShow(true, null);
});
progress?.WorkCompleted(progress);
}
private void du_onCompleted(object sender, CompletedEventArgs e)
{
IProgressable d = (IProgressable)sender;
OperationInfo op = (OperationInfo)d.State;
if (e.Success)
{
op.status = OperationStatus.Success;
}
else if (op.status == OperationStatus.Processing)
{
if (e.Cancel)
{
op.status = OperationStatus.Cancel;
}
else
{
op.status = OperationStatus.Fail;
op.errmsg = e.Exception == null ? string.Empty : e.Exception.Message;
}
}
}
private void du_onProgress(object sender, ProgressEventArgs e)
{
IProgressable d = (IProgressable)sender;
OperationInfo op = (OperationInfo)d.State;
op.totalSize = e.totalSize;
op.doneSize = e.doneSize;
fireOnProgress(op);
if (op.status != OperationStatus.Processing)
{
e.Cancel = true;
}
else if (IsPause)
{
e.Cancel = true;
op.status = OperationStatus.Pending;
}
else if (op.sid != Interlocked.Read(ref sid))
{
e.Cancel = true;
op.status = OperationStatus.Pending;
}
}
public void AddProgressable(IProgressable progressable)
{
TickTimer timer = null;
int timeRequired = progressable.Setup();
// Looks for an existing timer
foreach (TickTimer t in timers)
{
if (t.TotalTicksToCall == timeRequired)
{
timer = t;
timer.Add(ref progressable);
break;
}
}
// Makes a new timer
if (timer == null)
{
timer = new TickTimer(timeRequired);
timer.Add(ref progressable);
timers.Add(timer);
}
}
public Counter(IProgressable progressable, float max)
{
this.progressable = progressable ?? throw new ArgumentNullException(nameof(progressable));
this.max = max;
}
private ProgressWindow(IProgressable progressable)
{
Progress = progressable.Progress;
InitializeComponent();
}
public Progress(IProgressable prograssable)
{
this.prograssable = prograssable;
}
public ProgressAction(IProgressable progressable)
{
this.progressable = progressable;
}
// If we want to stream a music file, we can't
public StreamProgressInfo(IProgressable file)
{
this.file = file;
}
public static void Run(IProgressable progressable)
{
Run <ProgressView>(progressable);
}
public LoadProgress(string filter, IProgressable progressable)
{
Filter = filter;
Token = new ProgressToken(progressable);
}
public void Add(ref IProgressable progressable)
{
progressables.Add(progressable);
}
// If we want to stream a music file, we can't
public StreamProgressInfo(IProgressable progressable)
{
this.progressable = progressable;
}
private static async Task <StorageFile> DownloadFile(StorageFile destinationFile, Uri source, Addon addon, IProgressable progressable)
{
try
{
var result = Http.WebHttpClient.GetAsync(source);
var downloadProgessHandler = new DownloadProgressHandler()
{
Progressable = progressable != null ? progressable : addon
};
result.Progress = downloadProgessHandler.DownloadProgressCallback;
using (var filestream = await destinationFile.OpenAsync(FileAccessMode.ReadWrite))
{
var res = await result;
await res.Content.WriteToStreamAsync(filestream);
await filestream.FlushAsync();
}
}
catch (Exception ex)
{
Debug.WriteLine("[ERROR] DownloadFile. " + ex.Message + " " + ex.StackTrace);
}
return(destinationFile);
}
internal static async Task <StorageFile> DLWithHttpProgress(Addon addon, Download download, IProgressable progressable = null)
{
if (!NetworkInterface.GetIsNetworkAvailable())
{
return(null);
}
string downloadLink = GetDownLoadLink(addon, download);
var source = new Uri(downloadLink);
StorageFile destinationFile = await localFolder.CreateFileAsync(Util.RandomString(12) + ".zip", CreationCollisionOption.GenerateUniqueName);
return(await DownloadFile(destinationFile, source, addon, progressable));
}
private void OnTryAgainPressed(object sender, RoutedEventArgs e)
{
IProgressable item = (e.Source as MenuItem).DataContext as IProgressable;
item.DoWorkAsync();
}
internal static async Task <(string, List <string>)> UpdateAddonOld(Addon addon, Download download, StorageFile file, IProgressable progressable = null)
{
var extractFolderPath = localFolder.Path + @"\" + file.Name.Replace(".zip", "");
var subFoldersToDelete = new List <string>();
try
{
ZipFile.ExtractToDirectory(file.Path, extractFolderPath);
// int directoryCount = Directory.GetDirectories(extractFolderPath, "*", SearchOption.AllDirectories).Length;
float fileCount = Directory.GetFiles(extractFolderPath, "*", SearchOption.AllDirectories).Length;
var extractFolder = await StorageFolder.GetFolderFromPathAsync(extractFolderPath);
var folders = await extractFolder.GetFoldersAsync();
var gameFolder = await StorageFolder.GetFolderFromPathAsync(addon.Game.AbsolutePath);
//var tasks = folders.SelectMany(folder => CopyFolderAsync2(folder, gameFolder));
//await Task.WhenAll(tasks);
var foldersAsList = new List <StorageFolder>(folders);
subFoldersToDelete = foldersAsList.Select(f => f.Name)
.Where(name => !name.Equals(addon.FolderName, StringComparison.OrdinalIgnoreCase))
.ToList();
if (Singleton <SettingsViewModel> .Instance.IsDeleteOldFilesBeforeUpdate ?? false)
{
var subFolders = new List <string>(subFoldersToDelete)
{
addon.FolderName
};
await RemoveFolders(addon.Game.AbsolutePath, subFolders);
}
var counter = new Counter(progressable != null ? progressable : addon, Math.Max(fileCount, 1));
foreach (var folder in folders)
{
await CopyFolderAsync(folder, gameFolder, counter);
}
}
catch (Exception e)
{
Debug.WriteLine("[ERROR] UpdateAddon. " + e.Message + ", " + e.StackTrace);
}
return(extractFolderPath, subFoldersToDelete);
}
public void Remove(ref IProgressable progressable)
{
progressables.Remove(progressable);
}
public void setProgressable(IProgressable p)
{
_Progressable = p;
}
internal static async Task <List <string> > UpdateAddon2(Addon addon, StorageFile file, IProgressable progressable = null)
{
var subFoldersToDelete = new HashSet <string>();
try
{
Debug.WriteLine("Start: " + addon.FolderName + " " + DateTime.Now.ToString("mm:ss"));
int entries = 0;
using (ZipArchive archive = ZipFile.OpenRead(file.Path))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.FullName.Contains("/"))
{
var folderName = entry.FullName.Split("/").FirstOrDefault();
if (folderName != null && !folderName.Equals(addon.FolderName, StringComparison.OrdinalIgnoreCase))
{
subFoldersToDelete.Add(folderName);
}
}
entries++;
}
}
if (Singleton <SettingsViewModel> .Instance.IsDeleteOldFilesBeforeUpdate ?? false)
{
var folders = new List <string>(subFoldersToDelete)
{
addon.FolderName
};
await RemoveFolders(addon.Game.AbsolutePath, folders);
}
var gameFolder = await StorageFolder.GetFolderFromPathAsync(addon.Game.AbsolutePath);
var zipHelper = new ZipHelper()
{
Progressable = progressable != null ? progressable : addon, Entries = Math.Max(entries, 1)
};
zipHelper.PropertyChanged += UnzipProgress;
await zipHelper.UnZipFileAsync(file, gameFolder);
Debug.WriteLine("Copy done: " + addon.FolderName + " " + DateTime.Now.ToString("mm:ss"));
}
catch (Exception e)
{
Debug.WriteLine("[ERROR] UpdateAddon. " + e.Message + ", " + e.StackTrace);
}
return(subFoldersToDelete.ToList());
}
