initial commit

SEGATools/UserProcess/UserProcessBase.cs

@@ -0,0 +1,156 @@
+// Decompiled with JetBrains decompiler
+// Type: SEGATools.UserProcess.UserProcessBase
+// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08
+// MVID: D631183F-57B1-40A1-B502-5364D288307A
+// Assembly location: SEGATools.dll
+
+using System;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Threading;
+
+namespace SEGATools.UserProcess
+{
+  public class UserProcessBase : Component
+  {
+    protected static readonly Logger.ILog logger = Logger.CreateLog();
+    private HybridDictionary userStateToLifetime = new HybridDictionary();
+    private Container components;
+    private SendOrPostCallback onProgressReportDelegate;
+    private SendOrPostCallback onCompletedDelegate;
+    private SendOrPostCallback onProgressWaitingForUserConsentDelegate;
+    private SendOrPostCallback onUpdateUIViewDelegate;
+
+    public event AsyncOperationProgressChangedEventHandler AsyncOperationProgressChanged;
+
+    public event AsyncOperationCompletedEventHandler AsyncOperationCompleted;
+
+    public event AsyncOperationProgressWaitingForUserConsentEventHandler AsyncOperationWaitForUserConsent;
+
+    public event AsyncOperationProgressUpdateUIEventHandler AsyncOperationUpdateUIView;
+
+    public UserProcessBase(IContainer container)
+      : this()
+      => container.Add((IComponent) this);
+
+    public UserProcessBase()
+    {
+      this.InitializeComponent();
+      this.InitializeDelegates();
+    }
+
+    private void InitializeComponent() => this.components = new Container();
+
+    protected void InitializeDelegates()
+    {
+      this.onProgressReportDelegate = new SendOrPostCallback(this.ProgressReport);
+      this.onCompletedDelegate = new SendOrPostCallback(this.ProcessCompleted);
+      this.onProgressWaitingForUserConsentDelegate = new SendOrPostCallback(this.ProcessWaitingForUserConsent);
+      this.onUpdateUIViewDelegate = new SendOrPostCallback(this.ProcessUpdateUIView);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+      if (disposing && this.components != null)
+        this.components.Dispose();
+      base.Dispose(disposing);
+    }
+
+    public void CancelAsync(object taskId)
+    {
+      if (!(this.userStateToLifetime[taskId] is AsyncOperation))
+        return;
+      lock (this.userStateToLifetime.SyncRoot)
+        this.userStateToLifetime.Remove(taskId);
+    }
+
+    protected AsyncOperation CreateAsyncOperation(object taskId)
+    {
+      AsyncOperation operation = AsyncOperationManager.CreateOperation(taskId);
+      lock (this.userStateToLifetime.SyncRoot)
+      {
+        if (this.userStateToLifetime.Contains(taskId))
+          throw new ArgumentException("Task ID parameter must be unique", nameof (taskId));
+        this.userStateToLifetime[taskId] = (object) operation;
+      }
+      return operation;
+    }
+
+    protected bool TaskCanceled(AsyncOperation asyncOp) => asyncOp != null && this.userStateToLifetime[asyncOp.UserSuppliedState] == null;
+
+    protected void ReportProgress(UserProcessProgressChangedEventArgs e, AsyncOperation asyncOp)
+    {
+      asyncOp.Post(this.onProgressReportDelegate, (object) e);
+      Thread.Sleep(0);
+    }
+
+    protected void ReportCompletion(string Filename, Exception exception, AsyncOperation asyncOp)
+    {
+      if (asyncOp == null)
+        return;
+      bool canceled = this.RemoveTask(asyncOp);
+      UserProcessCompletedEventArgs completedEventArgs = new UserProcessCompletedEventArgs(Filename, exception, canceled, asyncOp.UserSuppliedState);
+      this.EndTask(asyncOp, (object) completedEventArgs);
+    }
+
+    protected bool AskForUserConsent(
+      UserProcessWaitingForUserConsentEventArgs e,
+      AsyncOperation asyncOp)
+    {
+      asyncOp.Post(this.onProgressWaitingForUserConsentDelegate, (object) e);
+      e.ResetEvent.WaitOne(-1, true);
+      return this.TaskCanceled(asyncOp);
+    }
+
+    protected void UpdateUIView(UserProcessUpdateUIViewEventArgs e, AsyncOperation asyncOp) => asyncOp?.Post(this.onUpdateUIViewDelegate, (object) e);
+
+    private bool RemoveTask(AsyncOperation asyncOp)
+    {
+      bool flag = this.TaskCanceled(asyncOp);
+      if (!flag)
+      {
+        lock (this.userStateToLifetime.SyncRoot)
+          this.userStateToLifetime.Remove(asyncOp.UserSuppliedState);
+      }
+      return flag;
+    }
+
+    private void EndTask(AsyncOperation asyncOp, object SendOrPostCallbackArg) => asyncOp.PostOperationCompleted(this.onCompletedDelegate, SendOrPostCallbackArg);
+
+    private void ProgressReport(object operationState) => this.OnProgressChanged(operationState as UserProcessProgressChangedEventArgs);
+
+    private void ProcessCompleted(object operationState) => this.OnProgressCompleted(operationState as UserProcessCompletedEventArgs);
+
+    private void ProcessWaitingForUserConsent(object operationState) => this.OnProgressWaitingForUserConsent(operationState as UserProcessWaitingForUserConsentEventArgs);
+
+    private void ProcessUpdateUIView(object operationState) => this.OnProgressUpdateUIView(operationState as UserProcessUpdateUIViewEventArgs);
+
+    private void OnProgressChanged(UserProcessProgressChangedEventArgs e)
+    {
+      if (this.AsyncOperationProgressChanged == null)
+        return;
+      this.AsyncOperationProgressChanged(e);
+    }
+
+    private void OnProgressCompleted(UserProcessCompletedEventArgs e)
+    {
+      if (this.AsyncOperationCompleted == null)
+        return;
+      this.AsyncOperationCompleted((object) this, e);
+    }
+
+    private void OnProgressWaitingForUserConsent(UserProcessWaitingForUserConsentEventArgs e)
+    {
+      if (this.AsyncOperationWaitForUserConsent == null)
+        return;
+      this.AsyncOperationWaitForUserConsent(e);
+    }
+
+    private void OnProgressUpdateUIView(UserProcessUpdateUIViewEventArgs e)
+    {
+      if (this.AsyncOperationUpdateUIView == null)
+        return;
+      this.AsyncOperationUpdateUIView(e);
+    }
+  }
+}