source: branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/Controls/ProgressView.cs @ 15415

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace HeuristicLab.MainForm.WindowsForms {
  internal sealed partial class ProgressView : UserControl {
    private const int defaultControlHeight = 88;
    private const int collapsedControlHeight = 55;

    private readonly Control control;
    public Control Control {
      get { return control; }
    }

    private readonly IProgress content;
    public IProgress Content {
      get { return content; }
    }

    public ProgressView(Control control, IProgress content)
      : base() {
      if (control == null) throw new ArgumentNullException("control");
      if (content == null) throw new ArgumentNullException("content");
      InitializeComponent();

      this.control = control;
      this.content = content;

      UpdateButtonsState();
      if (content.Visible) ShowProgress();
      RegisterContentEvents();
    }

    /// <summary> 
    /// Clean up any resources being used.
    /// </summary>
    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
    protected override void Dispose(bool disposing) {
      DeregisterContentEvents();
      HideProgress();

      if (disposing && (components != null)) {
        components.Dispose();
      }
      base.Dispose(disposing);
    }

    private void RegisterContentEvents() {
      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.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.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;
      BringToFront();

      UpdateProgressValue();
      UpdateProgressMessage();
      UpdateButtonsState();
      Visible = true;
    }

    private void HideProgress() {
      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.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 UpdateProgressMessage() {
      if (control.InvokeRequired) {
        control.Invoke((Action)UpdateProgressMessage);
        return;
      }

      messageLabel.Text = content.Message;
    }


    private void UpdateProgressValue() {
      // prevent problems with object disposal and invoke as suggested by http://stackoverflow.com/a/18647091
      if (!IsHandleCreated) return;
      if (InvokeRequired) {
        try {
          Invoke((Action)UpdateProgressValue);
        } 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 {
        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);
    }
  }
}