Index: branches/EnhancedProgress/HeuristicLab.Clients.Hive/3.3/HiveClient.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.Clients.Hive/3.3/HiveClient.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.Clients.Hive/3.3/HiveClient.cs	(revision 15415)
@@ -265,5 +265,5 @@
 
         // upload Job
-        refreshableJob.Progress.Status = "Uploading Job...";
+        refreshableJob.Progress.Message = "Uploading Job...";
         refreshableJob.Job.Id = HiveServiceLocator.Instance.CallHiveService((s) => s.AddJob(refreshableJob.Job));
         refreshableJob.Job = HiveServiceLocator.Instance.CallHiveService((s) => s.GetJob(refreshableJob.Job.Id)); // update owner and permissions
@@ -275,5 +275,5 @@
 
         // upload plugins
-        refreshableJob.Progress.Status = "Uploading plugins...";
+        refreshableJob.Progress.Message = "Uploading plugins...";
         this.OnlinePlugins = HiveServiceLocator.Instance.CallHiveService((s) => s.GetPlugins());
         this.AlreadyUploadedPlugins = new List<Plugin>();
@@ -283,5 +283,5 @@
 
         // upload tasks
-        refreshableJob.Progress.Status = "Uploading tasks...";
+        refreshableJob.Progress.Message = "Uploading tasks...";
 
         var tasks = new List<TS.Task>();
@@ -380,5 +380,5 @@
         lock (jobCountLocker) {
           progress.ProgressValue = (double)taskCount[0] / totalJobCount;
-          progress.Status = string.Format("Uploaded task ({0} of {1})", taskCount[0], totalJobCount);
+          progress.Message = string.Format("Uploaded task ({0} of {1})", taskCount[0], totalJobCount);
         }
 
@@ -416,5 +416,5 @@
         totalJobCount = allTasks.Count();
 
-        refreshableJob.Progress.Status = "Downloading tasks...";
+        refreshableJob.Progress.Message = "Downloading tasks...";
         downloader = new TaskDownloader(allTasks.Select(x => x.Id));
         downloader.StartAsync();
@@ -422,5 +422,5 @@
         while (!downloader.IsFinished) {
           refreshableJob.Progress.ProgressValue = downloader.FinishedCount / (double)totalJobCount;
-          refreshableJob.Progress.Status = string.Format("Downloading/deserializing tasks... ({0}/{1} finished)", downloader.FinishedCount, totalJobCount);
+          refreshableJob.Progress.Message = string.Format("Downloading/deserializing tasks... ({0}/{1} finished)", downloader.FinishedCount, totalJobCount);
           Thread.Sleep(500);
 
@@ -432,5 +432,5 @@
         var parents = allHiveTasks.Values.Where(x => !x.Task.ParentTaskId.HasValue);
 
-        refreshableJob.Progress.Status = "Downloading/deserializing complete. Displaying tasks...";
+        refreshableJob.Progress.Message = "Downloading/deserializing complete. Displaying tasks...";
         // build child-task tree
         foreach (HiveTask hiveTask in parents) {
Index: branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.cs	(revision 15415)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Runtime.InteropServices;
 using System.Windows.Forms;
 
@@ -40,12 +41,13 @@
     public ProgressView(Control control, IProgress content)
       : base() {
-      if (control == null) throw new ArgumentNullException("control", "The control is null.");
-      if (content == null) throw new ArgumentNullException("content", "The passed progress is null.");
+      if (control == null) throw new ArgumentNullException("control");
+      if (content == null) throw new ArgumentNullException("content");
       InitializeComponent();
 
       this.control = control;
       this.content = content;
-      if (content.ProgressState == ProgressState.Started)
-        ShowProgress();
+
+      UpdateButtonsState();
+      if (content.Visible) ShowProgress();
       RegisterContentEvents();
     }
@@ -66,77 +68,118 @@
 
     private void RegisterContentEvents() {
-      content.StatusChanged += new EventHandler(progress_StatusChanged);
-      content.ProgressValueChanged += new EventHandler(progress_ProgressValueChanged);
       content.ProgressStateChanged += new EventHandler(Content_ProgressStateChanged);
+      content.MessageChanged += new EventHandler(Content_MessageChanged);
+      content.ProgressBarModeChanged += new EventHandler(Content_ProgressBarModeChanged);
+      content.ProgressValueChanged += new EventHandler(Content_ProgressValueChanged);
+      content.VisibleChanged += new EventHandler(Content_VisibleChanged);
+      content.CanBeStoppedChanged += new EventHandler(Content_CanBeStoppedChanged);
       content.CanBeCanceledChanged += new EventHandler(Content_CanBeCanceledChanged);
     }
     private void DeregisterContentEvents() {
-      content.StatusChanged -= new EventHandler(progress_StatusChanged);
-      content.ProgressValueChanged -= new EventHandler(progress_ProgressValueChanged);
       content.ProgressStateChanged -= new EventHandler(Content_ProgressStateChanged);
+      content.MessageChanged -= new EventHandler(Content_MessageChanged);
+      content.ProgressBarModeChanged -= new EventHandler(Content_ProgressBarModeChanged);
+      content.ProgressValueChanged -= new EventHandler(Content_ProgressValueChanged);
+      content.VisibleChanged -= new EventHandler(Content_VisibleChanged);
+      content.CanBeStoppedChanged -= new EventHandler(Content_CanBeStoppedChanged);
       content.CanBeCanceledChanged -= new EventHandler(Content_CanBeCanceledChanged);
     }
 
+    private void Content_ProgressStateChanged(object sender, EventArgs e) {
+      UpdateProgressState();
+      UpdateButtonsState();
+    }
+
+    private void Content_MessageChanged(object sender, EventArgs e) {
+      UpdateProgressMessage();
+    }
+
+    private void Content_ProgressBarModeChanged(object sender, EventArgs e) {
+      UpdateProgressValue();
+    }
+    private void Content_ProgressValueChanged(object sender, EventArgs e) {
+      UpdateProgressValue();
+    }
+
+    private void Content_VisibleChanged(object sender, EventArgs e) {
+      if (content.Visible)
+        ShowProgress();
+      else
+        HideProgress();
+    }
+
+    private void Content_CanBeStoppedChanged(object sender, EventArgs e) {
+      UpdateButtonsState();
+    }
+    private void Content_CanBeCanceledChanged(object sender, EventArgs e) {
+      UpdateButtonsState();
+    }
+
     private void ShowProgress() {
-      if (Control.InvokeRequired) {
-        Control.Invoke((Action)ShowProgress);
-        return;
-      }
-      int height = Content.CanBeCanceled ? Height : collapsedControlHeight;
-
-      Left = (Control.ClientRectangle.Width / 2) - (Width / 2);
-      Top = (Control.ClientRectangle.Height / 2) - (height / 2);
+      if (control.InvokeRequired) {
+        control.Invoke((Action)ShowProgress);
+        return;
+      }
+
+      int height = (content.CanBeStopped || content.CanBeCanceled) ? Height : collapsedControlHeight;
+
+      Left = (control.ClientRectangle.Width / 2) - (Width / 2);
+      Top = (control.ClientRectangle.Height / 2) - (height / 2);
       Anchor = AnchorStyles.None;
 
       control.Enabled = false;
-      Parent = Control.Parent;
+      Parent = control.Parent;
       BringToFront();
 
       UpdateProgressValue();
-      UpdateProgressStatus();
-      UpdateCancelButton();
+      UpdateProgressMessage();
+      UpdateButtonsState();
       Visible = true;
     }
 
     private void HideProgress() {
-      if (InvokeRequired) Invoke((Action)HideProgress);
-      else {
-        control.Enabled = true;
-        Parent = null;
-        Visible = false;
-      }
-    }
-
-    private void progress_StatusChanged(object sender, EventArgs e) {
-      UpdateProgressStatus();
-    }
-
-    private void progress_ProgressValueChanged(object sender, EventArgs e) {
-      UpdateProgressValue();
-    }
-
-    private void Content_ProgressStateChanged(object sender, EventArgs e) {
+      if (control.InvokeRequired) {
+        control.Invoke((Action)HideProgress);
+        return;
+      }
+
+      control.Enabled = true;
+      Parent = null;
+      Visible = false;
+    }
+
+    private void UpdateProgressState() {
+      if (control.InvokeRequired) {
+        control.Invoke((Action)UpdateProgressState);
+        return;
+      }
+
       switch (content.ProgressState) {
-        case ProgressState.Finished: HideProgress(); break;
-        case ProgressState.Canceled: HideProgress(); break;
-        case ProgressState.Started: ShowProgress(); break;
+        case ProgressState.Started:
+          progressBar.SetState(ProgressBarState.Normal);
+          break;
+        case ProgressState.Finished:
+          HideProgress();
+          progressBar.SetState(ProgressBarState.Normal);
+          break;
+        case ProgressState.Stopped:
+          progressBar.SetState(ProgressBarState.Warning);
+          break;
+        case ProgressState.Canceled:
+          progressBar.SetState(ProgressBarState.Error);
+          break;
         default: throw new NotSupportedException("The progress state " + content.ProgressState + " is not supported by the ProgressView.");
       }
     }
 
-    private void Content_CanBeCanceledChanged(object sender, EventArgs e) {
-      UpdateCancelButton();
-    }
-
-    private void UpdateCancelButton() {
-      cancelButton.Visible = content != null && content.CanBeCanceled;
-      cancelButton.Enabled = content != null && content.CanBeCanceled;
-
-      if (content != null && content.CanBeCanceled) {
-        Height = defaultControlHeight;
-      } else if (content != null && !content.CanBeCanceled) {
-        Height = collapsedControlHeight;
-      }
-    }
+    private void UpdateProgressMessage() {
+      if (control.InvokeRequired) {
+        control.Invoke((Action)UpdateProgressMessage);
+        return;
+      }
+
+      messageLabel.Text = content.Message;
+    }
+
 
     private void UpdateProgressValue() {
@@ -146,32 +189,56 @@
         try {
           Invoke((Action)UpdateProgressValue);
-        }
-        catch (InvalidOperationException) {
+        } catch (InvalidOperationException) {
           // swallow ObjectDisposedException 
           // which might occur if the invoke call is executed after or while the control is disposing
         }
+        return;
+      }
+
+      if (content.ProgressBarMode == ProgressBarMode.Continuous) {
+        progressBar.Style = ProgressBarStyle.Continuous;
+        progressBar.Value = (int)Math.Round(progressBar.Minimum + content.ProgressValue * (progressBar.Maximum - progressBar.Minimum));
       } else {
-        if (content != null) {
-          double progressValue = content.ProgressValue;
-          if (progressValue <= 0.0 || progressValue > 1.0) {
-            progressBar.Style = ProgressBarStyle.Marquee;
-          } else {
-            progressBar.Style = ProgressBarStyle.Blocks;
-            progressBar.Value =
-              (int)Math.Round(progressBar.Minimum + progressValue * (progressBar.Maximum - progressBar.Minimum));
-          }
-        }
-      }
-    }
-
-    private void UpdateProgressStatus() {
-      if (InvokeRequired) Invoke((Action)UpdateProgressStatus);
-      else if (content != null)
-        statusLabel.Text = content.Status;
-    }
-
+        progressBar.Style = ProgressBarStyle.Marquee;
+      }
+    }
+
+    private void UpdateButtonsState() {
+      if (control.InvokeRequired) {
+        control.Invoke((Action)UpdateButtonsState);
+        return;
+      }
+
+      stopButton.Visible = content.CanBeStopped;
+      stopButton.Enabled = content.ProgressState == ProgressState.Started && content.CanBeStopped;
+
+      cancelButton.Visible = content.CanBeCanceled;
+      cancelButton.Enabled = content.ProgressState == ProgressState.Started && content.CanBeCanceled;
+
+      if (content.CanBeStopped || content.CanBeCanceled) {
+        Height = defaultControlHeight;
+      } else {
+        Height = collapsedControlHeight;
+      }
+    }
+
+    private void stopButton_Click(object sender, EventArgs e) {
+      content.Stop();
+    }
     private void cancelButton_Click(object sender, EventArgs e) {
       content.Cancel();
     }
   }
+
+  // https://stackoverflow.com/a/9753302
+  internal enum ProgressBarState {
+    Normal = 1, Error = 2, Warning = 3
+  }
+  internal static class ProgressBarStateExtension {
+    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)]
+    private static extern IntPtr SendMessage(IntPtr hWnd, uint msg, IntPtr w, IntPtr l);
+    public static void SetState(this ProgressBar pBar, ProgressBarState state) {
+      SendMessage(pBar.Handle, 1040, (IntPtr)state, IntPtr.Zero);
+    }
+  }
 }
Index: branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.designer.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.designer.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.designer.cs	(revision 15415)
@@ -27,5 +27,5 @@
     private System.ComponentModel.IContainer components = null;
 
-   
+
     #region Component Designer generated code
 
@@ -36,8 +36,11 @@
     private void InitializeComponent() {
       this.progressBar = new System.Windows.Forms.ProgressBar();
-      this.statusLabel = new System.Windows.Forms.Label();
+      this.messageLabel = new System.Windows.Forms.Label();
       this.cancelButton = new System.Windows.Forms.Button();
       this.panel = new System.Windows.Forms.Panel();
+      this.flowLayoutPanel = new System.Windows.Forms.FlowLayoutPanel();
+      this.stopButton = new System.Windows.Forms.Button();
       this.panel.SuspendLayout();
+      this.flowLayoutPanel.SuspendLayout();
       this.SuspendLayout();
       // 
@@ -52,17 +55,16 @@
       this.progressBar.TabIndex = 0;
       // 
-      // statusLabel
+      // messageLabel
       // 
-      this.statusLabel.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+      this.messageLabel.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-      this.statusLabel.Location = new System.Drawing.Point(3, 33);
-      this.statusLabel.Name = "statusLabel";
-      this.statusLabel.Size = new System.Drawing.Size(352, 17);
-      this.statusLabel.TabIndex = 1;
+      this.messageLabel.Location = new System.Drawing.Point(3, 33);
+      this.messageLabel.Name = "messageLabel";
+      this.messageLabel.Size = new System.Drawing.Size(352, 17);
+      this.messageLabel.TabIndex = 1;
       // 
       // cancelButton
       // 
-      this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
-      this.cancelButton.Location = new System.Drawing.Point(280, 53);
+      this.cancelButton.Location = new System.Drawing.Point(274, 3);
       this.cancelButton.Name = "cancelButton";
       this.cancelButton.Size = new System.Drawing.Size(75, 23);
@@ -78,11 +80,35 @@
             | System.Windows.Forms.AnchorStyles.Right)));
       this.panel.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
+      this.panel.Controls.Add(this.flowLayoutPanel);
       this.panel.Controls.Add(this.progressBar);
-      this.panel.Controls.Add(this.cancelButton);
-      this.panel.Controls.Add(this.statusLabel);
+      this.panel.Controls.Add(this.messageLabel);
       this.panel.Location = new System.Drawing.Point(0, 0);
       this.panel.Name = "panel";
       this.panel.Size = new System.Drawing.Size(360, 88);
       this.panel.TabIndex = 3;
+      // 
+      // flowLayoutPanel
+      // 
+      this.flowLayoutPanel.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+            | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.flowLayoutPanel.Controls.Add(this.cancelButton);
+      this.flowLayoutPanel.Controls.Add(this.stopButton);
+      this.flowLayoutPanel.Location = new System.Drawing.Point(3, 53);
+      this.flowLayoutPanel.Name = "flowLayoutPanel";
+      this.flowLayoutPanel.RightToLeft = System.Windows.Forms.RightToLeft.Yes;
+      this.flowLayoutPanel.Size = new System.Drawing.Size(352, 30);
+      this.flowLayoutPanel.TabIndex = 3;
+      // 
+      // stopButton
+      // 
+      this.stopButton.Dock = System.Windows.Forms.DockStyle.Left;
+      this.stopButton.Location = new System.Drawing.Point(193, 3);
+      this.stopButton.Name = "stopButton";
+      this.stopButton.Size = new System.Drawing.Size(75, 23);
+      this.stopButton.TabIndex = 3;
+      this.stopButton.Text = "Stop";
+      this.stopButton.UseVisualStyleBackColor = true;
+      this.stopButton.Click += new System.EventHandler(this.stopButton_Click);
       // 
       // ProgressView
@@ -93,4 +119,5 @@
       this.Size = new System.Drawing.Size(360, 88);
       this.panel.ResumeLayout(false);
+      this.flowLayoutPanel.ResumeLayout(false);
       this.ResumeLayout(false);
 
@@ -100,7 +127,9 @@
 
     private System.Windows.Forms.ProgressBar progressBar;
-    private System.Windows.Forms.Label statusLabel;
+    private System.Windows.Forms.Label messageLabel;
     private System.Windows.Forms.Button cancelButton;
     private System.Windows.Forms.Panel panel;
+    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel;
+    private System.Windows.Forms.Button stopButton;
   }
 }
Index: branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs	(revision 15415)
@@ -353,4 +353,5 @@
     /// Adds a <see cref="ProgressView"/> to the <see cref="ContentView"/>s showing the specified content.
     /// </summary>
+    [Obsolete]
     public IProgress AddOperationProgressToContent(IContent content, string progressMessage, bool addToObjectGraphObjects = true) {
       if (InvokeRequired) {
@@ -371,5 +372,6 @@
         contentViews = contentViews.Where(v => v.Content == content);
 
-      var progress = new Progress(progressMessage, ProgressState.Started);
+      var progress = new Progress();
+      progress.Start(progressMessage);
       foreach (var contentView in contentViews) {
         progressViews.Add(new ProgressView(contentView, progress));
@@ -383,6 +385,8 @@
     /// Adds a <see cref="ProgressView"/> to the specified view.
     /// </summary>
+    [Obsolete]
     public IProgress AddOperationProgressToView(Control control, string progressMessage) {
-      var progress = new Progress(progressMessage, ProgressState.Started);
+      var progress = new Progress();
+      progress.Start(progressMessage);
       AddOperationProgressToView(control, progress);
       return progress;
Index: branches/EnhancedProgress/HeuristicLab.MainForm/3.3/Interfaces/IProgress.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.MainForm/3.3/Interfaces/IProgress.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.MainForm/3.3/Interfaces/IProgress.cs	(revision 15415)
@@ -24,66 +24,40 @@
 
 namespace HeuristicLab.MainForm {
-  public enum ProgressState { Started = 1, Canceled = 2, Finished = 3 };
+  public enum ProgressState { Started, Finished, Stopped, Canceled }
+  public enum ProgressBarMode { Continuous, Marquee }
 
   public interface IProgress : IContent {
+    ProgressState ProgressState { get; }
+    string Message { get; set; }
+    ProgressBarMode ProgressBarMode { get; set; }
     /// <summary>
-    /// Gets or sets the currently associated status text with the progress.
-    /// </summary>
-    string Status { get; set; }
-    /// <summary>
-    /// Gets or sets the currently associated progress value in the range (0;1].
-    ///  Values outside this range are permitted and need to be handled in some feasible manner.
+    /// Gets or sets the currently associated progress value in the range [0;1] (values outside the range are truncated).
+    /// Changing the ProgressValue when ProgressBarMode is Marquee raises an Exception.
     /// </summary>
     double ProgressValue { get; set; }
-    /// <summary>
-    /// Gets or sets the current state of the progress. Every progress starts in state
-    /// Started and then becomes either Canceled or Finished.
-    /// If it is reused it may be Started again.
-    /// </summary>
-    ProgressState ProgressState { get; }
-    /// <summary>
-    /// Returns whether the operation can be canceled or not.
-    /// This can change during the course of the progress.
-    /// </summary>
+    bool Visible { get; set; }
+    bool CanBeStopped { get; }
     bool CanBeCanceled { get; }
 
     /// <summary>
-    /// Requests the operation behind the process to cancel.
-    /// Check the !ProgressState property when the cancellation succeeded.
-    /// The corresponding event will also notify of a success.
+    /// Start (or Restart) a progress with ProgressBarMode Marquee
     /// </summary>
-    /// <exception cref="NotSupportedException">Thrown when cancellation is not supported.</exception>
+    void Start(string message);
+    /// <summary>
+    /// Start (or Restart) a progress with ProgressBarMode Continues
+    /// </summary>
+    void Start(string message, double progressValue);
+    void Finish();
+    void Stop();
     void Cancel();
-    /// <summary>
-    /// Sets the ProgressValue to 1 and the ProgressState to Finished.
-    /// </summary>
-    void Finish();
 
-    /// <summary>
-    /// Starts or restarts a Progress. 
-    /// </summary>
-    void Start();
-
-    void Start(string status);
-
-    /// <summary>
-    /// The status text changed.
-    /// </summary>
-    event EventHandler StatusChanged;
-    /// <summary>
-    /// The value of the progress changed. This is the (0;1] progress value from starting to finish. Values outside this range are permitted and need to be handled in some feasible manner.
-    /// </summary>
+    event EventHandler ProgressStateChanged;
+    event EventHandler MessageChanged;
+    event EventHandler ProgressBarModeChanged;
     event EventHandler ProgressValueChanged;
-    /// <summary>
-    /// The state of the progress changed. The handler is supposed to query the ProgressState property.
-    /// </summary>
-    event EventHandler ProgressStateChanged;
-    /// <summary>
-    /// The progress' ability to cancel changed.
-    /// </summary>
+    event EventHandler VisibleChanged;
+    event EventHandler CanBeStoppedChanged;
     event EventHandler CanBeCanceledChanged;
-    /// <summary>
-    /// A cancelation is requested.
-    /// </summary>
+    event EventHandler StopRequested;
     event EventHandler CancelRequested;
   }
Index: branches/EnhancedProgress/HeuristicLab.MainForm/3.3/Progress.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.MainForm/3.3/Progress.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.MainForm/3.3/Progress.cs	(revision 15415)
@@ -24,26 +24,4 @@
 namespace HeuristicLab.MainForm {
   public class Progress : IProgress {
-    private string status;
-    public string Status {
-      get { return status; }
-      set {
-        if (status != value) {
-          status = value;
-          OnStatusChanged();
-        }
-      }
-    }
-
-    private double progressValue;
-    public double ProgressValue {
-      get { return progressValue; }
-      set {
-        if (progressValue != value) {
-          progressValue = value;
-          OnProgressChanged();
-        }
-      }
-    }
-
     private ProgressState progressState;
     public ProgressState ProgressState {
@@ -57,4 +35,61 @@
     }
 
+    private string message;
+    public string Message {
+      get { return message; }
+      set {
+        if (message != value) {
+          message = value;
+          OnMessageChanged();
+        }
+      }
+    }
+
+    private ProgressBarMode progressBarMode;
+    public ProgressBarMode ProgressBarMode {
+      get { return progressBarMode; }
+      set {
+        if (progressBarMode != value) {
+          progressBarMode = value;
+          OnProgressBarModeChanged();
+        }
+      }
+    }
+
+    private double progressValue;
+    public double ProgressValue {
+      get { return progressValue; }
+      set {
+        if (progressBarMode == ProgressBarMode.Marquee)
+          throw new InvalidOperationException("Cannot set ProgressValue while ProgressBar is in Marquee-Mode");
+        if (progressValue != value) {
+          progressValue = Math.Max(Math.Min(value, 1.0), 0.0);
+          OnProgressChanged();
+        }
+      }
+    }
+
+    private bool visible;
+    public bool Visible {
+      get { return visible; }
+      set {
+        if (visible != value) {
+          visible = value;
+          OnVisibleChanged();
+        }
+      }
+    }
+
+    private bool canBeStopped;
+    public bool CanBeStopped {
+      get { return canBeStopped; }
+      set {
+        if (canBeStopped != value) {
+          canBeStopped = value;
+          OnCanBeStoppedChanged();
+        }
+      }
+    }
+
     private bool canBeCanceled;
     public bool CanBeCanceled {
@@ -70,40 +105,60 @@
     public Progress() {
       progressState = ProgressState.Finished;
+      canBeStopped = false;
       canBeCanceled = false;
-    }
-    public Progress(string status)
-      : this() {
-      this.status = status;
-    }
-    public Progress(string status, ProgressState state)
-      : this() {
-      this.status = status;
-      this.progressState = state;
-    }
-
+      progressBarMode = ProgressBarMode.Marquee;
+      progressValue = 0.0;
+    }
+
+    public void Start(string message) {
+      ProgressState = ProgressState.Started;
+      ProgressBarMode = ProgressBarMode.Marquee;
+      Message = message;
+      Visible = true;
+    }
+    public void Start(string message, double progressValue) {
+      ProgressState = ProgressState.Started;
+      ProgressBarMode = ProgressBarMode.Continuous;
+      ProgressValue = progressValue;
+      Message = message;
+      Visible = true;
+    }
+
+    public void Finish() {
+      if (ProgressBarMode == ProgressBarMode.Continuous && ProgressValue != 1.0)
+        ProgressValue = 1.0;
+      ProgressState = ProgressState.Finished;
+      Visible = false;
+    }
+
+    public void Stop() {
+      if (canBeStopped) {
+        ProgressState = ProgressState.Stopped;
+        OnStopRequested();
+      } else throw new NotSupportedException("This progress cannot be stopped.");
+    }
     public void Cancel() {
-      if (canBeCanceled)
+      if (canBeCanceled) {
+        ProgressState = ProgressState.Canceled;
         OnCancelRequested();
-    }
-
-    public void Finish() {
-      if (ProgressValue != 1.0) ProgressValue = 1.0;
-      ProgressState = ProgressState.Finished;
-    }
-
-    public void Start() {
-      ProgressValue = 0.0;
-      ProgressState = ProgressState.Started;
-    }
-
-    public void Start(string status) {
-      Start();
-      Status = status;
+      } else throw new NotSupportedException("This progress cannot be canceled.");
     }
 
     #region Event Handler
-    public event EventHandler StatusChanged;
-    private void OnStatusChanged() {
-      var handler = StatusChanged;
+    public event EventHandler ProgressStateChanged;
+    private void OnProgressStateChanged() {
+      var handler = ProgressStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler MessageChanged;
+    private void OnMessageChanged() {
+      var handler = MessageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ProgressBarModeChanged;
+    private void OnProgressBarModeChanged() {
+      var handler = ProgressBarModeChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
@@ -115,7 +170,13 @@
     }
 
-    public event EventHandler ProgressStateChanged;
-    private void OnProgressStateChanged() {
-      var handler = ProgressStateChanged;
+    public event EventHandler VisibleChanged;
+    private void OnVisibleChanged() {
+      var handler = VisibleChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler CanBeStoppedChanged;
+    private void OnCanBeStoppedChanged() {
+      var handler = CanBeStoppedChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
@@ -127,9 +188,14 @@
     }
 
+    public event EventHandler StopRequested;
+    private void OnStopRequested() {
+      var handler = StopRequested;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
     public event EventHandler CancelRequested;
     private void OnCancelRequested() {
       var handler = CancelRequested;
-      if (handler != null) throw new NotSupportedException("Cancel request was ignored.");
-      else handler(this, EventArgs.Empty);
+      if (handler != null) handler(this, EventArgs.Empty);
     }
     #endregion
Index: branches/EnhancedProgress/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
===================================================================
--- branches/EnhancedProgress/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 15405)
+++ branches/EnhancedProgress/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 15415)
@@ -40,5 +40,5 @@
     private readonly ISymbolicDataAnalysisSolutionImpactValuesCalculator impactCalculator;
 
-    private readonly IProgress progress = new Progress();
+    private readonly IProgress progress = new Progress() { CanBeCanceled = true, CanBeStopped = true };
 
     private enum TreeState { Valid, Invalid }
@@ -183,5 +183,5 @@
       treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
 
-      progress.Start("Calculate Impact and Replacement Values ...");
+      progress.Start("Calculate Impact and Replacement Values ...", 0);
       var impactAndReplacementValues = await Task.Run(() => CalculateImpactAndReplacementValues(tree));
       await Task.Delay(500); // wait for progressbar to finish animation
@@ -298,5 +298,5 @@
 
     private async void btnOptimizeConstants_Click(object sender, EventArgs e) {
-      progress.Start("Optimizing Constants ...");
+      progress.Start("Optimizing Constants ...", 0);
       var tree = (ISymbolicExpressionTree)Content.Model.SymbolicExpressionTree.Clone();
       var newTree = await Task.Run(() => OptimizeConstants(tree, progress));
