Changeset 9893


Ignore:
Timestamp:
08/21/13 23:08:47 (8 years ago)
Author:
ascheibe
Message:

#1042

  • applied mkommends progress view patch
  • adapted Hive views accordingly
  • made some minor improvements (more to come...)
Location:
trunk/sources
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Clients.Access.Views/3.3/ClientViews/ClientView.cs

    r9456 r9893  
    2020#endregion
    2121
    22 using System;
    2322using HeuristicLab.Core.Views;
    2423using HeuristicLab.MainForm;
     
    3433    }
    3534
    36     private ProgressView progressView;
    37     private Progress progress;
    38 
    3935    public ClientView() {
    4036      InitializeComponent();
    41       progress = new Progress() {
    42         CanBeCanceled = false,
    43         ProgressState = ProgressState.Finished
    44       };
    45     }
    46 
    47     protected override void DeregisterContentEvents() {
    48       if (progressView != null) {
    49         progressView.Content = null;
    50         progressView.Dispose();
    51         progressView = null;
    52       }
    53       base.DeregisterContentEvents();
    54     }
    55 
    56     protected override void RegisterContentEvents() {
    57       base.RegisterContentEvents();
    58       progressView = new ProgressView(this, progress);
    5937    }
    6038
     
    9876
    9977    public void StartProgressView() {
    100       if (InvokeRequired) {
    101         Invoke(new Action(StartProgressView));
    102       } else {
    103         progress.Status = "Downloading client information. Please be patient.";
    104         progress.ProgressState = ProgressState.Started;
    105       }
     78      var message = "Downloading client information. Please be patient.";
     79      MainFormManager.GetMainForm<HeuristicLab.MainForm.WindowsForms.MainForm>().AddOperationProgressToView(this, message);
    10680    }
    10781
    10882    public void FinishProgressView() {
    109       if (InvokeRequired) {
    110         Invoke(new Action(FinishProgressView));
    111       } else {
    112         progress.Finish();
    113       }
     83      MainFormManager.GetMainForm<HeuristicLab.MainForm.WindowsForms.MainForm>().RemoveOperationProgressFromView(this);
    11484    }
    11585  }
  • trunk/sources/HeuristicLab.Clients.Hive.JobManager/3.3/Views/HiveResourceSelector.cs

    r9456 r9893  
    6464      imageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.MonitorLarge);
    6565      imageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.NetworkCenterLarge);
    66       progress = new Progress() {
    67         CanBeCanceled = false,
    68         ProgressState = ProgressState.Finished
    69       };
     66      progress = new Progress();
    7067    }
    7168
    7269    protected override void DeregisterContentEvents() {
    7370      if (progressView != null) {
    74         progressView.Content = null;
    7571        progressView.Dispose();
    7672        progressView = null;
  • trunk/sources/HeuristicLab.Clients.Hive.JobManager/3.3/Views/RefreshableHiveJobListView.cs

    r9540 r9893  
    5050      this.itemsListView.ListViewItemSorter = new ListViewItemDateComparer(0, SortOrder.Ascending);
    5151
    52       progress = new Progress() {
    53         CanBeCanceled = false,
    54         ProgressState = ProgressState.Finished
    55       };
     52      progress = new Progress();
    5653      progressView = new ProgressView(this, progress);
    5754    }
     
    129126
    130127    private void DeleteHiveJobsAsync(object items) {
    131       progress.Status = "Deleting job...";
    132       progress.ProgressState = ProgressState.Started;
    133       progress.ProgressValue = 0.0;
     128      progress.Start("Deleting job...");
    134129      foreach (RefreshableJob item in (List<RefreshableJob>)items) {
    135130        Content.Remove(item);
     
    227222      if (disposing) {
    228223        if (components != null) components.Dispose();
    229         progressView.Content = null;
    230224        progressView.Dispose();
     225        progressView = null;
    231226      }
    232227      base.Dispose(disposing);
  • trunk/sources/HeuristicLab.Clients.Hive.JobManager/3.3/Views/RefreshableHiveJobView.cs

    r9710 r9893  
    4242  [Content(typeof(RefreshableJob), true)]
    4343  public partial class RefreshableHiveJobView : HeuristicLab.Core.Views.ItemView {
    44     private Progress progress;
    4544    private ProgressView progressView;
    4645    private HiveResourceSelectorDialog hiveResourceSelectorDialog;
     
    5857    public RefreshableHiveJobView() {
    5958      InitializeComponent();
    60       progress = new Progress() {
    61         CanBeCanceled = false,
    62         ProgressState = ProgressState.Finished
    63       };
    6459    }
    6560
     
    7267      Content.ExceptionOccured += new EventHandler<EventArgs<Exception>>(Content_ExceptionOccured);
    7368      Content.StateLogListChanged += new EventHandler(Content_StateLogListChanged);
    74       Content.IsProgressingChanged += new EventHandler(Content_IsProgressingChanged);
    7569      Content.HiveTasksChanged += new EventHandler(Content_HiveTasksChanged);
    7670      Content.ExecutionStateChanged += new EventHandler(Content_ExecutionStateChanged);
     
    7872      Content.Loaded += new EventHandler(Content_Loaded);
    7973      Content.TaskReceived += new EventHandler(Content_TaskReceived);
    80       progressView = new ProgressView(this, progress);
     74      progressView = new ProgressView(this, Content.Progress);
    8175    }
    8276
     
    8882      Content.ExceptionOccured -= new EventHandler<EventArgs<Exception>>(Content_ExceptionOccured);
    8983      Content.StateLogListChanged -= new EventHandler(Content_StateLogListChanged);
    90       Content.IsProgressingChanged -= new EventHandler(Content_IsProgressingChanged);
    9184      Content.HiveTasksChanged -= new EventHandler(Content_HiveTasksChanged);
    9285      Content.ExecutionStateChanged -= new EventHandler(Content_ExecutionStateChanged);
     
    9588      Content.TaskReceived -= new EventHandler(Content_TaskReceived);
    9689      if (progressView != null) {
    97         progressView.Content = null;
    9890        progressView.Dispose();
    9991        progressView = null;
     
    159151      Content_HiveExperimentChanged(this, EventArgs.Empty);
    160152      Content_HiveTasksChanged(this, EventArgs.Empty);
    161       Content_IsProgressingChanged(this, EventArgs.Empty);
    162153      Content_StateLogListChanged(this, EventArgs.Empty);
    163154      HiveExperiment_PropertyChanged(this, new PropertyChangedEventArgs("Id"));
     
    336327      if (Content != null && Content.Job != null) {
    337328        RegisterHiveExperimentEvents();
    338         Content_IsProgressingChanged(sender, e);
    339329      }
    340330    }
     
    410400        var task = System.Threading.Tasks.Task.Factory.StartNew(ResumeJobAsync, Content);
    411401        task.ContinueWith((t) => {
    412           progress.Finish();
     402          Content.Progress.Finish();
    413403          MessageBox.Show("An error occured resuming the job. See the log for more information.", "HeuristicLab Hive Job Manager", MessageBoxButtons.OK, MessageBoxIcon.Error);
    414404          Content.Log.LogException(t.Exception);
     
    422412      var task = System.Threading.Tasks.Task.Factory.StartNew(PauseJobAsync, Content);
    423413      task.ContinueWith((t) => {
    424         progress.Finish();
     414        Content.Progress.Finish();
    425415        MessageBox.Show("An error occured pausing the job. See the log for more information.", "HeuristicLab Hive Job Manager", MessageBoxButtons.OK, MessageBoxIcon.Error);
    426416        Content.Log.LogException(t.Exception);
     
    431421      var task = System.Threading.Tasks.Task.Factory.StartNew(StopJobAsync, Content);
    432422      task.ContinueWith((t) => {
    433         progress.Finish();
     423        Content.Progress.Finish();
    434424        MessageBox.Show("An error occured stopping the job. See the log for more information.", "HeuristicLab Hive Job Manager", MessageBoxButtons.OK, MessageBoxIcon.Error);
    435425        Content.Log.LogException(t.Exception);
     
    439429
    440430    private void PauseJobAsync(object job) {
    441       progress.Status = "Pausing job...";
    442       progress.ProgressState = ProgressState.Started;
     431      Content.Progress.Start("Pausing job...");
    443432      HiveClient.PauseJob((RefreshableJob)job);
    444       progress.Finish();
     433      Content.Progress.Finish();
    445434    }
    446435
    447436    private void StopJobAsync(object job) {
    448       progress.Status = "Stopping job...";
    449       progress.ProgressState = ProgressState.Started;
     437      Content.Progress.Start("Stopping job...");
    450438      HiveClient.StopJob((RefreshableJob)job);
    451       progress.Finish();
     439      Content.Progress.Finish();
    452440    }
    453441
    454442    private void ResumeJobAsync(object job) {
    455       progress.Status = "Resuming job...";
    456       progress.ProgressState = ProgressState.Started;
     443      Content.Progress.Start("Resuming job...");
    457444      HiveClient.ResumeJob((RefreshableJob)job);
    458       progress.Finish();
     445      Content.Progress.Finish();
    459446    }
    460447
     
    507494        stopButton.Enabled = Content.IsControllable && Content.ExecutionState == ExecutionState.Started && !Content.IsProgressing;
    508495        resetButton.Enabled = false;
    509       }
    510     }
    511     #endregion
    512 
    513     #region Progress reporting
    514     private void Content_IsProgressingChanged(object sender, EventArgs e) {
    515       if (this.InvokeRequired) {
    516         Invoke(new EventHandler(Content_IsProgressingChanged), sender, e);
    517       } else {
    518         if (Content != null && Content.Progress != null && Content.IsProgressing) {
    519           progressView.Content = Content.Progress;
    520         } else if (Content != null) {
    521           progressView.Content = progress;
    522         }
    523496      }
    524497    }
  • trunk/sources/HeuristicLab.Clients.Hive.Views/3.3/HiveTasks/OptimizerHiveTaskView.cs

    r9456 r9893  
    4545    public OptimizerHiveTaskView() {
    4646      InitializeComponent();
    47       progress = new Progress() {
    48         CanBeCanceled = false,
    49         ProgressState = ProgressState.Finished
    50       };
     47      progress = new Progress();
    5148    }
    5249
     
    7067      Content.IsControllableChanged -= new EventHandler(Content_IsControllableChanged);
    7168      if (progressView != null) {
    72         progressView.Content = null;
    7369        progressView.Dispose();
    7470        progressView = null;
     
    110106
    111107    private void PauseTaskAsync() {
    112       progress.Status = "Pausing task. Please be patient for the command to take effect.";
    113       progress.ProgressState = ProgressState.Started;
     108      progress.Start("Pausing task. Please be patient for the command to take effect.");
    114109      Content.Pause();
    115110      progress.Finish();
     
    117112
    118113    private void StopTaskAsync() {
    119       progress.Status = "Stopping task. Please be patient for the command to take effect.";
    120       progress.ProgressState = ProgressState.Started;
     114      progress.Start("Stopping task. Please be patient for the command to take effect.");
    121115      Content.Stop();
    122116      progress.Finish();
     
    124118
    125119    private void ResumeTaskAsync() {
    126       progress.Status = "Resuming task. Please be patient for the command to take effect.";
    127       progress.ProgressState = ProgressState.Started;
     120      progress.Start("Resuming task. Please be patient for the command to take effect.");
    128121      Content.Restart();
    129122      progress.Finish();
  • trunk/sources/HeuristicLab.Clients.Hive/3.3/HiveClient.cs

    r9456 r9893  
    265265      try {
    266266        refreshableJob.IsProgressing = true;
    267         refreshableJob.Progress = new Progress("Connecting to server...");
     267        refreshableJob.Progress.Start("Connecting to server...");
    268268        IEnumerable<string> resourceNames = ToResourceNameList(refreshableJob.Job.ResourceNames);
    269269        var resourceIds = new List<Guid>();
     
    424424      var hiveExperiment = refreshableJob.Job;
    425425      refreshableJob.IsProgressing = true;
    426       refreshableJob.Progress = new Progress();
    427426      TaskDownloader downloader = null;
    428427
     
    431430        IEnumerable<LightweightTask> allTasks;
    432431
    433         refreshableJob.Progress.Status = "Connecting to Server...";
    434432        // fetch all task objects to create the full tree of tree of HiveTask objects
    435         refreshableJob.Progress.Status = "Downloading list of tasks...";
     433        refreshableJob.Progress.Start("Downloading list of tasks...");
    436434        allTasks = HiveServiceLocator.Instance.CallHiveService(s => s.GetLightweightJobTasksWithoutStateLog(hiveExperiment.Id));
    437435        totalJobCount = allTasks.Count();
  • trunk/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs

    r9456 r9893  
    178178    #region Constructors and Cloning
    179179    public RefreshableJob() {
     180      this.progress = new Progress();
    180181      this.refreshAutomatically = false;
    181182      this.Job = new Job();
     
    186187    }
    187188    public RefreshableJob(Job hiveJob) {
     189      this.progress = new Progress();
    188190      this.refreshAutomatically = true;
    189191      this.Job = hiveJob;
  • trunk/sources/HeuristicLab.Clients.OKB.Views/3.3/RunCreation/Views/OKBExperimentUploadView.cs

    r9456 r9893  
    5959    public OKBExperimentUploadView() {
    6060      InitializeComponent();
    61       progress = new Progress() {
    62         CanBeCanceled = false,
    63         ProgressState = ProgressState.Finished
    64       };
     61      progress = new Progress();
    6562    }
    6663
     
    103100      RunCreationClient.Instance.Refreshed -= new EventHandler(RunCreationClient_Refreshed);
    104101      if (progressView != null) {
    105         progressView.Content = null;
    106102        progressView.Dispose();
    107103        progressView = null;
  • trunk/sources/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.cs

    r9868 r9893  
    2121
    2222using System;
    23 using System.ComponentModel;
    2423using System.Windows.Forms;
    2524
    2625namespace HeuristicLab.MainForm.WindowsForms {
    27   [View("ProgressView")]
    28   [Content(typeof(IProgress), true)]
    29   public partial class ProgressView : AsynchronousContentView {
    30     private const int DefaultCancelTimeoutMs = 3000;
    31     private readonly IView view;
    32 
    33     [Category("Custom"), Description("The time that the process is allowed to exit.")]
    34     [DefaultValue(DefaultCancelTimeoutMs)]
    35     public int CancelTimeoutMs { get; set; }
    36     private bool ShouldSerializeCancelTimeoutMs() { return CancelTimeoutMs != DefaultCancelTimeoutMs; }
    37 
    38     public new IProgress Content {
    39       get { return (IProgress)base.Content; }
    40       set { base.Content = value; }
     26  public sealed partial class ProgressView : UserControl {
     27    private readonly Control control;
     28    public Control Control {
     29      get { return control; }
    4130    }
    4231
    43     private Control Control {
    44       get { return (Control)view; }
     32    private readonly IProgress content;
     33    public IProgress Content {
     34      get { return content; }
    4535    }
    4636
    47     public bool DisposeOnFinish { get; set; }
     37    public ProgressView(Control control, IProgress content)
     38      : base() {
     39      if (control == null) throw new ArgumentNullException("control", "The control is null.");
     40      if (content == null) throw new ArgumentNullException("content", "The passed progress is null.");
     41      InitializeComponent();
    4842
    49     public ProgressView() {
    50       InitializeComponent();
     43      this.control = control;
     44      this.content = content;
     45      if (content.ProgressState == ProgressState.Started)
     46        ShowProgress();
     47      RegisterContentEvents();
    5148    }
    5249
    53     public ProgressView(IView view)
    54       : this() {
    55       if (view == null) throw new ArgumentNullException("view", "The view is null.");
    56       if (!(view is Control)) throw new ArgumentException("The view is not a control.", "view");
    57       this.view = view;
     50    private void RegisterContentEvents() {
     51      content.StatusChanged += new EventHandler(progress_StatusChanged);
     52      content.ProgressValueChanged += new EventHandler(progress_ProgressValueChanged);
     53      content.ProgressStateChanged += new EventHandler(Content_ProgressStateChanged);
     54      content.CanBeCanceledChanged += new EventHandler(Content_CanBeCanceledChanged);
    5855    }
    59     public ProgressView(IView view, IProgress progress)
    60       : this(view) {
    61       Content = progress;
    62     }
    63 
    64     public static ProgressView Attach(IView view, IProgress progress, bool disposeOnFinish = false) {
    65       return new ProgressView(view, progress) {
    66         DisposeOnFinish = disposeOnFinish
    67       };
    68     }
    69 
    70     protected override void RegisterContentEvents() {
    71       Content.StatusChanged += new EventHandler(progress_StatusChanged);
    72       Content.ProgressValueChanged += new EventHandler(progress_ProgressValueChanged);
    73       Content.ProgressStateChanged += new EventHandler(Content_ProgressStateChanged);
    74       Content.CanBeCanceledChanged += new EventHandler(Content_CanBeCanceledChanged);
    75       base.RegisterContentEvents();
    76     }
    77 
    78     protected override void DeregisterContentEvents() {
    79       base.DeregisterContentEvents();
    80       Content.StatusChanged -= new EventHandler(progress_StatusChanged);
    81       Content.ProgressValueChanged -= new EventHandler(progress_ProgressValueChanged);
    82       Content.ProgressStateChanged -= new EventHandler(Content_ProgressStateChanged);
    83       Content.CanBeCanceledChanged -= new EventHandler(Content_CanBeCanceledChanged);
    84     }
    85 
    86     protected override void OnContentChanged() {
    87       base.OnContentChanged();
    88       if (Content == null) {
    89         HideProgress();
    90       } else {
    91         if (Content.ProgressState == ProgressState.Started)
    92           ShowProgress();
    93       }
    94     }
    95 
    96     protected override void SetEnabledStateOfControls() {
    97       base.SetEnabledStateOfControls();
    98       cancelButton.Visible = Content != null && Content.CanBeCanceled;
    99       cancelButton.Enabled = Content != null && Content.CanBeCanceled && !ReadOnly;
     56    private void DeregisterContentEvents() {
     57      content.StatusChanged -= new EventHandler(progress_StatusChanged);
     58      content.ProgressValueChanged -= new EventHandler(progress_ProgressValueChanged);
     59      content.ProgressStateChanged -= new EventHandler(Content_ProgressStateChanged);
     60      content.CanBeCanceledChanged -= new EventHandler(Content_CanBeCanceledChanged);
    10061    }
    10162
    10263    private void ShowProgress() {
    103       if (InvokeRequired) Invoke((Action)ShowProgress);
    104       else {
    105         if (view != null) {
    106           Left = (Control.ClientRectangle.Width / 2) - (Width / 2);
    107           Top = (Control.ClientRectangle.Height / 2) - (Height / 2);
    108           Anchor = AnchorStyles.None;
     64      if (Control.InvokeRequired) {
     65        Control.Invoke((Action)ShowProgress);
     66        return;
     67      }
     68      Left = (Control.ClientRectangle.Width / 2) - (Width / 2);
     69      Top = (Control.ClientRectangle.Height / 2) - (Height / 2);
     70      Anchor = AnchorStyles.None;
    10971
    110           LockBackground();
    111           Parent = Control.Parent;
    112           BringToFront();
    113         }
    114         UpdateProgressValue();
    115         UpdateProgressStatus();
    116         Visible = true;
    117       }
     72      control.Enabled = false;
     73      Parent = Control.Parent;
     74      BringToFront();
     75
     76      UpdateProgressValue();
     77      UpdateProgressStatus();
     78      UpdateCancelButton();
     79      Visible = true;
    11880    }
    11981
     
    12183      if (InvokeRequired) Invoke((Action)HideProgress);
    12284      else {
    123         if (view != null) {
    124           Parent = null;
    125           UnlockBackground();
    126         }
     85        control.Enabled = true;
     86        Parent = null;
    12787        Visible = false;
    12888      }
     
    13898
    13999    private void Content_ProgressStateChanged(object sender, EventArgs e) {
    140       switch (Content.ProgressState) {
    141         case ProgressState.Finished:
    142           HideProgress();
    143           if (DisposeOnFinish) {
    144             Content = null;
    145             Dispose();
    146           }
    147           break;
     100      switch (content.ProgressState) {
     101        case ProgressState.Finished: HideProgress(); break;
    148102        case ProgressState.Canceled: HideProgress(); break;
    149103        case ProgressState.Started: ShowProgress(); break;
     104        default: throw new NotSupportedException("The progress state " + content.ProgressState + " is not supported by the ProgressView.");
    150105      }
    151106    }
    152107
    153108    private void Content_CanBeCanceledChanged(object sender, EventArgs e) {
    154       SetEnabledStateOfControls();
     109      UpdateCancelButton();
    155110    }
    156111
    157     private void LockBackground() {
    158       if (InvokeRequired) Invoke((Action)LockBackground);
    159       else {
    160         view.Enabled = false;
    161       }
    162     }
    163 
    164     private void UnlockBackground() {
    165       if (InvokeRequired) Invoke((Action)UnlockBackground);
    166       else {
    167         view.Enabled = true;
    168       }
     112    private void UpdateCancelButton() {
     113      cancelButton.Visible = content != null && content.CanBeCanceled;
     114      cancelButton.Enabled = content != null && content.CanBeCanceled;
    169115    }
    170116
     
    172118      if (InvokeRequired) Invoke((Action)UpdateProgressValue);
    173119      else {
    174         if (Content != null) {
    175           double progressValue = Content.ProgressValue;
     120        if (content != null) {
     121          double progressValue = content.ProgressValue;
    176122          if (progressValue <= 0.0 || progressValue > 1.0) {
    177             if (progressBar.Style != ProgressBarStyle.Marquee)
    178               progressBar.Style = ProgressBarStyle.Marquee;
     123            progressBar.Style = ProgressBarStyle.Marquee;
    179124          } else {
    180             if (progressBar.Style != ProgressBarStyle.Blocks)
    181               progressBar.Style = ProgressBarStyle.Blocks;
     125            progressBar.Style = ProgressBarStyle.Blocks;
    182126            progressBar.Value = (int)Math.Round(progressBar.Minimum + progressValue * (progressBar.Maximum - progressBar.Minimum));
    183127          }
     
    188132    private void UpdateProgressStatus() {
    189133      if (InvokeRequired) Invoke((Action)UpdateProgressStatus);
    190       else if (Content != null)
    191         statusLabel.Text = Content.Status;
     134      else if (content != null)
     135        statusLabel.Text = content.Status;
    192136    }
    193137
    194138    private void cancelButton_Click(object sender, EventArgs e) {
    195       if (Content != null) {
    196         try {
    197           Content.Cancel(CancelTimeoutMs);
    198           ReadOnly = true;
    199           cancelButtonTimer.Interval = CancelTimeoutMs;
    200           cancelButtonTimer.Start();
    201         } catch (NotSupportedException nse) {
    202           PluginInfrastructure.ErrorHandling.ShowErrorDialog(nse);
    203         }
    204       }
    205     }
    206 
    207     private void cancelButtonTimer_Tick(object sender, EventArgs e) {
    208       cancelButtonTimer.Stop();
    209       if (Visible) ReadOnly = false;
     139      content.Cancel();
    210140    }
    211141  }
  • trunk/sources/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.designer.cs

    r9456 r9893  
    3232    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
    3333    protected override void Dispose(bool disposing) {
     34      DeregisterContentEvents();
    3435      if (disposing && (components != null)) {
    3536        components.Dispose();
     
    5051      this.cancelButton = new System.Windows.Forms.Button();
    5152      this.panel = new System.Windows.Forms.Panel();
    52       this.cancelButtonTimer = new System.Windows.Forms.Timer(this.components);
    5353      this.panel.SuspendLayout();
    5454      this.SuspendLayout();
     
    9797      this.panel.TabIndex = 3;
    9898      //
    99       // cancelButtonTimer
    100       //
    101       this.cancelButtonTimer.Tick += new System.EventHandler(this.cancelButtonTimer_Tick);
    102       //
    10399      // ProgressView
    104100      //
     
    109105      this.panel.ResumeLayout(false);
    110106      this.ResumeLayout(false);
    111 
    112107    }
    113108
     
    118113    private System.Windows.Forms.Button cancelButton;
    119114    private System.Windows.Forms.Panel panel;
    120     private System.Windows.Forms.Timer cancelButtonTimer;
    121115  }
    122116}
  • trunk/sources/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs

    r9865 r9893  
    3030namespace HeuristicLab.MainForm.WindowsForms {
    3131  public partial class MainForm : Form, IMainForm {
    32     private readonly Dictionary<IContent, IProgress> contentProgressLookup;
    33     private readonly Dictionary<IView, IProgress> viewProgressLookup;
    3432    private bool initialized;
    3533    private int appStartingCursors;
     
    4139      this.views = new Dictionary<IView, Form>();
    4240      this.userInterfaceItems = new List<IUserInterfaceItem>();
    43       this.contentProgressLookup = new Dictionary<IContent, IProgress>();
    44       this.viewProgressLookup = new Dictionary<IView, IProgress>();
    4541      this.initialized = false;
    4642      this.showContentInViewHost = false;
     
    347343        CloseView(view, closeReason);
    348344    }
     345    #endregion
     346
     347    #region progress views
     348    private readonly Dictionary<IContent, IProgress> contentProgressLookup = new Dictionary<IContent, IProgress>();
     349    private readonly Dictionary<IView, IProgress> viewProgressLookup = new Dictionary<IView, IProgress>();
     350    private readonly List<ProgressView> progressViews = new List<ProgressView>();
    349351
    350352    /// <summary>
     
    355357        throw new ArgumentException("A progress is already registered for the specified content.", "content");
    356358
    357       var contentViews = Enumerable.Empty<IContentView>();
     359      var contentViews = views.Keys.OfType<ContentView>();
     360      if (!contentViews.Any(v => v.Content == content))
     361        throw new ArgumentException("The content is not displayed in a top-level view", "content");
     362
    358363      if (addToObjectGraphObjects) {
    359364        var containedObjects = content.GetObjectGraphObjects();
    360         contentViews = views.Keys.OfType<IContentView>().Where(v => containedObjects.Contains(v.Content));
     365        contentViews = contentViews.Where(v => containedObjects.Contains(v.Content));
    361366      } else
    362         contentViews = views.Keys.OfType<IContentView>().Where(v => v.Content == content);
    363 
    364       var progress = new Progress(progressMessage);
    365       foreach (var contentView in contentViews)
    366         ProgressView.Attach(contentView, progress, true);
     367        contentViews = contentViews.Where(v => v.Content == content);
     368
     369      var progress = new Progress(progressMessage, ProgressState.Started);
     370      foreach (var contentView in contentViews) {
     371        progressViews.Add(new ProgressView((Control)contentView, progress));
     372      }
    367373
    368374      contentProgressLookup[content] = progress;
     
    376382        throw new ArgumentException("A progress is already registered for the specified view.", "view");
    377383
    378       var progress = new Progress(progressMessage);
    379       ProgressView.Attach(view, progress, true);
     384      var control = view as Control;
     385      if (control == null) throw new ArgumentException("The passed view must be a control.", "view");
     386
     387      var progress = new Progress(progressMessage, ProgressState.Started);
     388      progressViews.Add(new ProgressView(control, progress));
    380389      viewProgressLookup[view] = progress;
    381390    }
     
    390399
    391400      progress.Finish();
     401      foreach (var progressView in progressViews.Where(v => v.Content == progress).ToList()) {
     402        progressView.Dispose();
     403        progressViews.Remove(progressView);
     404      }
    392405      contentProgressLookup.Remove(content);
    393406    }
     
    402415
    403416      progress.Finish();
     417      foreach (var progressView in progressViews.Where(v => v.Content == progress).ToList()) {
     418        progressView.Dispose();
     419        progressViews.Remove(progressView);
     420      }
    404421      viewProgressLookup.Remove(view);
    405422    }
  • trunk/sources/HeuristicLab.MainForm/3.3/Interfaces/IProgress.cs

    r9849 r9893  
    5555    /// <exception cref="NotSupportedException">Thrown when cancellation is not supported.</exception>
    5656    /// <param name="timeoutMs">The operation is given a certain timeout to cancel. If the operation doesn't cancel in this time it will be forcibly closed.</param>
    57     void Cancel(int timeoutMs);
     57    void Cancel(int timeoutMs = 0);
    5858    /// <summary>
    5959    /// Sets the ProgressValue to 1 and the ProgressState to Finished.
    6060    /// </summary>
    6161    void Finish();
     62
     63    void Start(string status);
     64
     65    void Start();
    6266
    6367    /// <summary>
  • trunk/sources/HeuristicLab.MainForm/3.3/Progress.cs

    r9849 r9893  
    7070
    7171    public Progress() {
    72       progressState = ProgressState.Started;
     72      progressState = ProgressState.Finished;
     73      canBeCanceled = false;
    7374    }
    7475    public Progress(string status)
     
    7677      this.status = status;
    7778    }
    78     public Progress(string status, double progressValue)
    79       : this(status) {
    80       this.progressValue = progressValue;
     79    public Progress(string status, ProgressState state)
     80      : this() {
     81      this.status = status;
     82      this.progressState = state;
    8183    }
    8284
    83     public void Cancel(int timeoutMs) {
     85    public void Cancel(int timeoutMs = 0) {
    8486      if (canBeCanceled)
    8587        OnCancelRequested(timeoutMs);
     
    9193    }
    9294
     95    public void Start() {
     96      ProgressValue = 0.0;
     97      ProgressState = ProgressState.Started;
     98    }
     99
     100    public void Start(string status) {
     101      Start();
     102      Status = status;
     103    }
     104
    93105    #region Event Handler
    94106    public event EventHandler StatusChanged;
    95107    private void OnStatusChanged() {
    96108      var handler = StatusChanged;
    97       try {
    98         if (handler != null) handler(this, EventArgs.Empty);
    99       } catch { }
     109      if (handler != null) handler(this, EventArgs.Empty);
    100110    }
    101111
     
    103113    private void OnProgressChanged() {
    104114      var handler = ProgressValueChanged;
    105       try {
    106         if (handler != null) handler(this, EventArgs.Empty);
    107       } catch { }
     115      if (handler != null) handler(this, EventArgs.Empty);
    108116    }
    109117
     
    111119    private void OnProgressStateChanged() {
    112120      var handler = ProgressStateChanged;
    113       try {
    114         if (handler != null) handler(this, EventArgs.Empty);
    115       } catch { }
     121      if (handler != null) handler(this, EventArgs.Empty);
    116122    }
    117123
     
    119125    private void OnCanBeCanceledChanged() {
    120126      var handler = CanBeCanceledChanged;
    121       try {
    122         if (handler != null) handler(this, EventArgs.Empty);
    123       } catch { }
     127      if (handler != null) handler(this, EventArgs.Empty);
     128
    124129    }
    125130
     
    127132    private void OnCancelRequested(int timeoutMs) {
    128133      var handler = CancelRequested;
    129       try {
    130         if (handler == null) throw new NotSupportedException("Cancel request was ignored.");
    131         else handler(this, new EventArgs<int>(timeoutMs));
    132       } catch { }
     134      if (handler != null) throw new NotSupportedException("Cancel request was ignored.");
     135      else handler(this, new EventArgs<int>(timeoutMs));
    133136    }
    134137    #endregion
Note: See TracChangeset for help on using the changeset viewer.