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
