public virtual IProgressTask <float, T> LoadWindowAsync <T> (IWindowManager windowManager, string name) where T : Window
{
if (windowManager == null)
{
windowManager = this.GetDefaultWindowManager();
}
ProgressTask <float, T> task = new ProgressTask <float, T> (p => DoLoad <T> (p, name));
return(task.Start(30).OnPostExecute(win => {
win.WindowManager = windowManager;
}));
}
private void StopPolling()
{
// Stop polling:
var timer = this.Timer;
if (timer != null)
{
Timer.Stop();
}
// Clear the task:
this.currentTask = null;
}
private void LoadVolume(IBackgroundTaskContext context)
{
try
{
ProgressTask mainTask = new ProgressTask();
mainTask.AddSubTask("BUILD", 90);
mainTask.AddSubTask("LAYOUT", 10);
context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessageInitializingMpr, mainTask.Progress)));
BackgroundTaskParams @params = (BackgroundTaskParams)context.UserState;
Volume volume = Volume.Create(@params.Frames,
delegate(int i, int count)
{
if (context.CancelRequested)
{
throw new BackgroundTaskCancelledException();
}
if (i == 0)
{
mainTask["BUILD"].AddSubTask("", count);
}
mainTask["BUILD"][""].Increment();
string message = string.Format(SR.MessageBuildingMprVolumeProgress, mainTask.Progress, i + 1, count, mainTask["BUILD"].Progress);
context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, message));
});
mainTask["BUILD"].MarkComplete();
context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessagePerformingMprWorkspaceLayout, mainTask.Progress)));
//call layout here b/c it could take a while
@params.SynchronizationContext.Send(delegate
{
_viewer = new MprViewerComponent(volume);
_viewer.Layout();
}, null);
mainTask["LAYOUT"].MarkComplete();
context.ReportProgress(new BackgroundTaskProgress(mainTask.IntPercent, string.Format(SR.MessageDone, mainTask.Progress)));
context.Complete();
}
catch (BackgroundTaskCancelledException)
{
context.Cancel();
}
catch (Exception ex)
{
context.Error(ex);
}
}
/// <inheritdoc/>
public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
{
return(new ProgressBar
{
MaxValue = task.MaxValue,
Value = task.Value,
Width = Width,
CompletedStyle = CompletedStyle,
FinishedStyle = FinishedStyle,
RemainingStyle = RemainingStyle,
IndeterminateStyle = IndeterminateStyle,
IsIndeterminate = task.IsIndeterminate,
});
}
//public InteractionRequest<CardBagViewModel> WheelRequest
//{
// get { return this.wheelRequest; }
//}
public void Download()
{
ProgressTask <float> task = new ProgressTask <float>(new Action <IProgressPromise <float> >(DoDownLoad));
task.OnPreExecute(() => {
this.command.Enabled = false;
this.progressBar.Enable = true;
}).OnProgressUpdate(progress => {
this.progressBar.Progress = progress;
}).OnFinish(() => {
this.command.Enabled = true;
this.progressBar.Enable = false;
this.command.Execute(null);
}).Start();
}
/// <summary>
/// 异步加载GameScene场景，带进度条
/// </summary>
private void LoadGameScene()
{
ProgressTask <float> task = new ProgressTask <float>(new Func <IProgressPromise <float>, IEnumerator>(DoLoadGameScene));
task.OnPreExecute(() =>
{
this.progressBar.Enable = true;//让进度条显示出来
}).OnProgressUpdate(progress =>
{
this.ProgressBar.Progress = progress;//实时更新进度
}).OnFinish(() =>
{
this.progressBar.Enable = false;//隐藏进度条
}).Start();
}
/// <summary>
/// Adds a task.
/// </summary>
/// <param name="description">The task description.</param>
/// <param name="settings">The task settings.</param>
/// <returns>The newly created task.</returns>
public ProgressTask AddTask(string description, ProgressTaskSettings settings)
{
if (settings is null)
{
throw new ArgumentNullException(nameof(settings));
}
lock (_taskLock)
{
var task = new ProgressTask(_taskId++, description, settings.MaxValue, settings.AutoStart);
_tasks.Add(task);
return(task);
}
}
/// <summary>
/// Simulate a unzip task.
/// </summary>
public IProgressTask <float> Unzip()
{
ProgressTask <float> task = new ProgressTask <float> (new Action <IProgressPromise <float> > (DoUnzip));
task.OnPreExecute(() => {
this.progressBar.Enable = true;
this.ProgressBar.Tip = R.startup_progressbar_tip_unziping;
}).OnProgressUpdate(progress => {
this.ProgressBar.Progress = progress; /* update progress */
}).OnPostExecute(() => {
this.ProgressBar.Tip = "";
}).OnFinish(() => {
this.progressBar.Enable = false;
});
return(task);
}
/// <inheritdoc/>
public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
{
var elapsed = task.ElapsedTime;
if (elapsed == null)
{
return(new Markup("--:--:--"));
}
if (elapsed.Value.TotalHours > 99)
{
return(new Markup("**:**:**"));
}
return(new Text($"{elapsed.Value:hh\\:mm\\:ss}", Style ?? Style.Plain));
}
/// <summary>
/// Simulate a loading task.
/// </summary>
/// <returns>The scene.</returns>
public IProgressTask <float> LoadScene()
{
ProgressTask <float> task = new ProgressTask <float> (new Func <IProgressPromise <float>, IEnumerator> (DoLoadScene));
task.OnPreExecute(() => {
this.progressBar.Enable = true;
this.ProgressBar.Tip = R.startup_progressbar_tip_loading;
}).OnProgressUpdate(progress => {
this.ProgressBar.Progress = progress; /* update progress */
}).OnPostExecute(() => {
this.ProgressBar.Tip = "";
}).OnFinish(() => {
this.progressBar.Enable = false;
});
return(task);
}
private void Progress_Starting(ProgressTask progressTask)
{
// We're only looking for this specific task:
if (this.currentTask != null || progressTask.TaskKey != this.TaskKey)
{
return;
}
// Keep track of this task so we can poll it:
this.currentTask = progressTask;
progressTask.EnablePolling(this.MaximumDepth);
// Start polling for progress:
Timer.Start();
progressTask.SetCallbackEnded(this.OnProgressEnding);
}
public void CanNail()
{
//arrange
var http = new HttpClient(new MockHttpMessageHandler());
var task = new ProgressTask(123, "test", 0, false);
var options = new NailgunSettings()
{
URL = new Uri("http://localhost"),
Requests = 5
};
var driller = new Nailer(http, task, options);
//act
var results = driller.Run();
//assert
Assert.Equal(5, results.Count);
}
/// <inheritdoc/>
public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
{
var total = ByteSize.FromBytes(task.MaxValue);
var cultureInfo = Culture ?? CultureInfo.CurrentCulture;
if (task.IsFinished)
{
return(new Markup($"[green]{total.ToString("#.#", cultureInfo)}[/]"));
}
else
{
var downloaded = ByteSize.FromBytes(task.Value);
double remainingValue;
switch (total.LargestWholeNumberSymbol)
{
case "b":
remainingValue = downloaded.Bits;
break;
case "B":
remainingValue = downloaded.Bytes;
break;
case "KB":
remainingValue = downloaded.Kilobytes;
break;
case "MB":
remainingValue = downloaded.Megabytes;
break;
case "GB":
remainingValue = downloaded.Gigabytes;
break;
default:
remainingValue = downloaded.Terabytes;
break;
}
return(new Markup(string.Format("{0:0.0}[grey]/[/]{1:0.0} [grey]{2}[/]", remainingValue,
total.LargestWholeNumberValue, total.LargestWholeNumberSymbol)));
}
}
public void CanHammer()
{
//arrange
var http = new HttpClient(new MockHttpMessageHandler());
var task = new ProgressTask(123, "test", 0, false);
var options = new HammerSettings
{
URL = new Uri("http://localhost"),
Min = 1,
Max = 100
};
var carpenter = new Carpenter(http, task, options);
//act
var results = carpenter.Run();
//assert
Assert.Equal(19, results.Count);
}
public void CanRenderColumn()
{
//arrange
var column = new LabelProgressColumn("[[ test ]]");
var console = new TestConsole();
var capabilities = new TestCapabilities();
var context = new RenderContext(capabilities);
var task = new ProgressTask(123, "test", 0, false);
//act
var markup = column.Render(context, task, TimeSpan.Zero) as Markup;
//assert
var segments = markup !.GetSegments(console).Select(s => s.Text);
var output = string.Join("", segments);
Assert.Equal("[ test ]", output);
}
public void CanDrill()
{
//arrange
var http = new HttpClient(new MockHttpMessageHandler());
var task = new ProgressTask(123, "test", 0, false);
var options = new DrillSettings
{
URL = new Uri("http://localhost"),
RPS = 1,
Duration = 1
};
var driller = new Driller(http, task, options);
//act
var results = driller.Run();
//assert
Assert.Equal(1, results.Count);
}
private async Task FetchPackagesDataAsync(ProgressTask task, List <Package> packages)
{
// Number of concurrent requests
// TODO: make variable via settings
var numberConcurrentRequests = 4;
// Number of total runs needed to make all requests
var numberRunsTotal = Math.Ceiling((double)packages.Count / numberConcurrentRequests);
// Number to increment progress bar = 100% / number of runs
var incrementBy = 100d / numberRunsTotal;
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
FindPackageByIdResource resource = await repository.GetResourceAsync <FindPackageByIdResource>();
for (var i = 0; i < numberRunsTotal; i++)
{
// Only take "number of allowed concurrent requests" packages at a time
var currentRunPackages = packages
.Skip(i * numberConcurrentRequests)
.Take(numberConcurrentRequests);
var tasks = currentRunPackages
.Select(p => resource.GetAllVersionsAsync(p.PackageName, cache, logger, cancellationToken));
await Task.WhenAll(tasks);
foreach (var(p, index) in currentRunPackages.Select((item, index) => (item, index)))
{
var versions = tasks.ElementAt(index).Result;
if (versions.Any())
{
p.LatestStableVersion = _nuGetVersionService.GetLatestStableVersion(versions);
p.LatestVersion = _nuGetVersionService.GetLatestVersion(versions);
}
}
task.Increment(incrementBy);
}
}
private static async Task <List <Recipe> > GetRecipes(
CraftingQuery craftingQuery,
ProgressTask progress
)
{
progress.StartTask();
try
{
return(await craftingQuery
.GetRecipes(
progress : new Progress <ICollectionContext>(ctx => UpdateProgress(ctx, progress))
)
.OrderByDescending(recipe => recipe.Id)
.ToListAsync());
}
finally
{
progress.StopTask();
}
}
/// <summary>
/// Simulate a loading task.
/// </summary>
public void LoadScene()
{
ProgressTask <float> task = new ProgressTask <float>(new Func <IProgressPromise <float>, IEnumerator>(DoLoadScene));
task.OnPreExecute(() =>
{
this.progressBar.Enable = true;
this.ProgressBar.Tip = R.startup_progressbar_tip_loading;
}).OnProgressUpdate(progress =>
{
this.ProgressBar.Progress = progress;/* update progress */
}).OnPostExecute(() =>
{
this.ProgressBar.Tip = "";
}).OnFinish(() =>
{
this.progressBar.Enable = false;
this.dismissRequest.Raise();/* Dismiss StartupWindow */
}).Start();
}
private static async Task <List <Item> > GetItems(
IReadOnlyCollection <int> itemIds,
ItemsQuery itemsQuery,
ProgressTask progress
)
{
var items = new List <Item>(itemIds.Count);
progress.StartTask();
await foreach (var item in itemsQuery.GetItemsByIds(
itemIds,
progress: new Progress <ICollectionContext>(ctx => UpdateProgress(ctx, progress))
))
{
items.Add(item);
}
progress.StopTask();
return(items);
}
/// <inheritdoc/>
public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
{
var total = new FileSize(task.MaxValue);
if (task.IsFinished)
{
return(new Markup(string.Format(
"[green]{0} {1}[/]",
total.Format(Culture),
total.Suffix)));
}
else
{
var downloaded = new FileSize(task.Value, total.Unit);
return(new Markup(string.Format(
"{0}[grey]/[/]{1} [grey]{2}[/]",
downloaded.Format(Culture),
total.Format(Culture),
total.Suffix)));
}
}
private static TaskManager <IProgressInteraction> CreateSavingTasksInitialization(Document document,
IProgressInteraction progress, out ProgressTask writingTask,
out List <ProgressTask> resourceTasks, out int count, out ProgressTask finalizingTask)
{
writingTask = new ProgressTask(10, "Writing document base data...");
var tasks = new List <ProgressTask>
{
writingTask
};
resourceTasks = new List <ProgressTask>();
count = document.Resources.Count;
for (var i = 0; i < count; i++)
{
var progressTask = new ProgressTask(10, $"Writing resource : {document.Resources[i].Name}...");
tasks.Add(progressTask);
resourceTasks.Add(progressTask);
}
finalizingTask = new ProgressTask(5, "Saving to file...");
tasks.Add(finalizingTask);
return(new TaskManager <IProgressInteraction>(progress, tasks));
}
protected override void OnDialogClosed(bool positiveResult)
{
base.OnDialogClosed(positiveResult);
if (positiveResult)
{
ulong paramValue;
String strRounds = edittext.Text;
if (!(ulong.TryParse(strRounds, out paramValue)))
{
Toast.MakeText(Context, Resource.String.error_param_not_number, ToastLength.Long).Show();
return;
}
if (paramValue < 1)
{
paramValue = 1;
}
Database db = App.Kp2a.GetDb();
ulong oldValue = ParamValue;
if (oldValue == paramValue)
{
return;
}
ParamValue = paramValue;
Handler handler = new Handler();
SaveDb save = new SaveDb(Context, App.Kp2a, new KdfNumberParamPreference.AfterSave(Context, handler, oldValue, this));
ProgressTask pt = new ProgressTask(App.Kp2a, Context, save);
pt.Run();
}
}
protected abstract SkiaChart WieldTool(ProgressTask task, T settings);
public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
{
var text = task.Description.Trim().PadRight(_width);
return(new Markup(text).Overflow(Overflow.Ellipsis).LeftAligned());
}
/// <summary>
/// Create a sequence of progress tasks for executing a process containing two or more operations.
/// </summary>
/// <typeparam name="TResult">The type of object returned by the first operation.</typeparam>
/// <param name="func">The first operation to execute.</param>
/// <param name="typeDescription">The type description use for the progress.</param>
/// <param name="operationDescription">The progress description to use for the first operation.</param>
/// <returns></returns>
protected ProgressTask <TResult> First <TResult>(Func <List <TResult> > func, string typeDescription, string operationDescription)
{
return(ProgressTask <TResult> .Create(func, this, typeDescription, operationDescription));
}
public ProgressColumnFixture(double completed, double total)
{
Column = new T();
Task = new ProgressTask(1, "Foo", total);
Task.Increment(completed);
}
public void AddTask(ProgressTask task)
{
m_tasks.Add(task);
}
public ProgressEnumerator(IEnumerable <T> source, ProgressTask progress)
{
this.source = source;
this.progress = progress;
}
public TaskElement(ProgressTask task)
{
Task = task;
}
public SpectreProgressTask(ProgressTask task)
{
_task = task;
}
protected override void OnDialogClosed(bool positiveResult)
{
base.OnDialogClosed(positiveResult);
if ( positiveResult ) {
ulong rounds;
String strRounds = RoundsView.Text;
if (!(ulong.TryParse(strRounds,out rounds)))
{
Toast.MakeText(Context, Resource.String.error_rounds_not_number, ToastLength.Long).Show();
return;
}
if ( rounds < 1 ) {
rounds = 1;
}
Database db = App.Kp2a.GetDb();
ulong oldRounds = db.KpDatabase.KeyEncryptionRounds;
if (oldRounds == rounds)
{
return;
}
db.KpDatabase.KeyEncryptionRounds = rounds;
Handler handler = new Handler();
SaveDb save = new SaveDb(Context, App.Kp2a, new AfterSave(Context, handler, oldRounds, this));
ProgressTask pt = new ProgressTask(App.Kp2a, Context, save);
pt.Run();
}
}
