source: branches/EnhancedProgress/HeuristicLab.MainForm.WindowsForms/3.3/MainForms/MainForm.cs @ 15446

Last change on this file since 15446 was 15446, checked in by pfleck, 5 years ago

#2845:

  • Start progres with initial progress value in several cases to use the progress value update.
  • Removed object disposal guard in ProgressView because it can block part of the initialization.
File size: 22.3 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using System.Windows.Forms;
26using HeuristicLab.Common;
27using HeuristicLab.PluginInfrastructure;
28using WeifenLuo.WinFormsUI.Docking;
29
30namespace HeuristicLab.MainForm.WindowsForms {
31  public partial class MainForm : Form, IMainForm {
32    private bool initialized;
33    private int appStartingCursors;
34    private int waitingCursors;
35
36    protected MainForm()
37      : base() {
38      InitializeComponent();
39      this.views = new Dictionary<IView, Form>();
40      this.userInterfaceItems = new List<IUserInterfaceItem>();
41      this.initialized = false;
42      this.showContentInViewHost = false;
43      appStartingCursors = 0;
44      waitingCursors = 0;
45    }
46
47    protected MainForm(Type userInterfaceItemType)
48      : this() {
49      this.userInterfaceItemType = userInterfaceItemType;
50    }
51
52    #region properties
53    private bool showContentInViewHost;
54    public bool ShowContentInViewHost {
55      get { return this.showContentInViewHost; }
56      set { this.showContentInViewHost = value; }
57    }
58
59    public string Title {
60      get { return this.Text; }
61      set {
62        if (InvokeRequired) {
63          Action<string> action = delegate (string s) { this.Title = s; };
64          Invoke(action, value);
65        } else
66          this.Text = value;
67      }
68    }
69
70    public override Cursor Cursor {
71      get { return base.Cursor; }
72      set {
73        if (InvokeRequired) {
74          Action<Cursor> action = delegate (Cursor c) { this.Cursor = c; };
75          Invoke(action, value);
76        } else
77          base.Cursor = value;
78      }
79    }
80
81    private Type userInterfaceItemType;
82    public Type UserInterfaceItemType {
83      get { return this.userInterfaceItemType; }
84    }
85
86    private Dictionary<IView, Form> views;
87    public IEnumerable<IView> Views {
88      get { return views.Keys; }
89    }
90
91    private IView activeView;
92    public IView ActiveView {
93      get { return this.activeView; }
94      protected set {
95        if (this.activeView != value) {
96          if (InvokeRequired) {
97            Action<IView> action = delegate (IView activeView) { this.ActiveView = activeView; };
98            Invoke(action, value);
99          } else {
100            this.activeView = value;
101            OnActiveViewChanged();
102          }
103        }
104      }
105    }
106
107    private List<IUserInterfaceItem> userInterfaceItems;
108    protected IEnumerable<IUserInterfaceItem> UserInterfaceItems {
109      get { return this.userInterfaceItems; }
110    }
111    #endregion
112
113    #region events
114    public event EventHandler ActiveViewChanged;
115    protected virtual void OnActiveViewChanged() {
116      if (InvokeRequired)
117        Invoke((MethodInvoker)OnActiveViewChanged);
118      else {
119        EventHandler handler = ActiveViewChanged;
120        if (handler != null)
121          handler(this, EventArgs.Empty);
122      }
123    }
124
125    public event EventHandler<ViewEventArgs> ViewClosed;
126    protected virtual void OnViewClosed(IView view) {
127      if (InvokeRequired) Invoke((Action<IView>)OnViewClosed, view);
128      else {
129        EventHandler<ViewEventArgs> handler = ViewClosed;
130        if (handler != null)
131          handler(this, new ViewEventArgs(view));
132      }
133    }
134
135    public event EventHandler<ViewShownEventArgs> ViewShown;
136    protected virtual void OnViewShown(IView view, bool firstTimeShown) {
137      if (InvokeRequired) Invoke((Action<IView, bool>)OnViewShown, view, firstTimeShown);
138      else {
139        EventHandler<ViewShownEventArgs> handler = ViewShown;
140        if (handler != null)
141          handler(this, new ViewShownEventArgs(view, firstTimeShown));
142      }
143    }
144
145    public event EventHandler<ViewEventArgs> ViewHidden;
146    protected virtual void OnViewHidden(IView view) {
147      if (InvokeRequired) Invoke((Action<IView>)OnViewHidden, view);
148      else {
149        EventHandler<ViewEventArgs> handler = ViewHidden;
150        if (handler != null)
151          handler(this, new ViewEventArgs(view));
152      }
153    }
154
155    public event EventHandler Changed;
156    protected void OnChanged() {
157      if (InvokeRequired)
158        Invoke((MethodInvoker)OnChanged);
159      else {
160        EventHandler handler = Changed;
161        if (handler != null)
162          Changed(this, EventArgs.Empty);
163      }
164    }
165
166    private void MainFormBase_Load(object sender, EventArgs e) {
167      if (!DesignMode) {
168        MainFormManager.RegisterMainForm(this);
169        this.CreateGUI();
170        if (!this.initialized) {
171          this.initialized = true;
172          this.OnInitialized(EventArgs.Empty);
173        }
174      }
175    }
176
177    protected virtual void OnInitialized(EventArgs e) { }
178
179    public virtual void UpdateTitle() { }
180
181    private void FormActivated(object sender, EventArgs e) {
182      this.ActiveView = GetView((Form)sender);
183    }
184
185    protected override void OnFormClosing(FormClosingEventArgs e) {
186      foreach (KeyValuePair<IView, Form> pair in this.views) {
187        DockForm dockForm = pair.Value as DockForm;
188        View view = pair.Key as View;
189        if (view != null && dockForm != null && dockForm.DockState != DockState.Document) {
190          view.CloseReason = CloseReason.ApplicationExitCall;
191          view.OnClosingHelper(dockForm, e);
192        }
193      }
194      base.OnFormClosing(e);
195    }
196
197    protected override void OnFormClosed(FormClosedEventArgs e) {
198      foreach (KeyValuePair<IView, Form> pair in this.views.ToList()) {
199        DockForm dockForm = pair.Value as DockForm;
200        View view = pair.Key as View;
201        if (view != null && dockForm != null && dockForm.DockState != DockState.Document) {
202          view.CloseReason = CloseReason.ApplicationExitCall;
203          view.OnClosedHelper(dockForm, e);
204          dockForm.Close();
205        }
206      }
207      base.OnFormClosed(e);
208    }
209    #endregion
210
211    #region create, get, show, hide, close views
212    protected virtual Form CreateForm(IView view) {
213      throw new NotImplementedException("CreateForm must be implemented in subclasses of MainForm.");
214    }
215
216    protected internal Form GetForm(IView view) {
217      if (views.ContainsKey(view))
218        return views[view];
219      return null;
220    }
221    protected IView GetView(Form form) {
222      return views.Where(x => x.Value == form).Single().Key;
223    }
224
225    public IContentView ShowContent(IContent content) {
226      if (content == null) throw new ArgumentNullException("Content cannot be null.");
227      Type viewType = MainFormManager.GetDefaultViewType(content.GetType());
228      if (viewType != null) return ShowContent(content, viewType);
229      return null;
230    }
231
232    public IContentView ShowContent<T>(T content, bool reuseExistingView, IEqualityComparer<T> comparer = null) where T : class, IContent {
233      if (content == null) throw new ArgumentNullException("Content cannot be null.");
234      if (!reuseExistingView) return ShowContent(content);
235
236      IContentView view = null;
237      if (comparer == null) view = Views.OfType<IContentView>().Where(v => (v.Content as T) == content).FirstOrDefault();
238      else view = Views.OfType<IContentView>().Where(v => comparer.Equals((v.Content as T), content)).FirstOrDefault();
239
240      if (view == null) view = ShowContent(content);
241      else view.Show();
242
243      return view;
244    }
245
246    public IContentView ShowContent(IContent content, Type viewType) {
247      if (InvokeRequired) return (IContentView)Invoke((Func<IContent, Type, IContentView>)ShowContent, content, viewType);
248      else {
249        if (content == null) throw new ArgumentNullException("Content cannot be null.");
250        if (viewType == null) throw new ArgumentNullException("ViewType cannot be null.");
251
252        IContentView view = null;
253        if (ShowContentInViewHost) {
254          ViewHost viewHost = new ViewHost();
255          viewHost.ViewType = viewType;
256          view = viewHost;
257
258        } else view = MainFormManager.CreateView(viewType);
259
260        view.Content = content;
261        view.Show();
262        return view;
263      }
264    }
265
266    internal void ShowView(IView view) {
267      if (InvokeRequired) Invoke((Action<IView>)ShowView, view);
268      else {
269        Form form = GetForm(view);
270        bool firstTimeShown = form == null;
271        if (firstTimeShown) {
272          form = CreateForm(view);
273          form.Activated += new EventHandler(FormActivated);
274          form.FormClosed += new FormClosedEventHandler(ChildFormClosed);
275          view.Changed += new EventHandler(View_Changed);
276          views[view] = form;
277        }
278        this.ShowView(view, firstTimeShown);
279        this.OnViewShown(view, firstTimeShown);
280      }
281    }
282
283    private void View_Changed(object sender, EventArgs e) {
284      IView view = (IView)sender;
285      if (view == this.ActiveView)
286        this.OnActiveViewChanged();
287      this.OnChanged();
288    }
289
290    protected virtual void ShowView(IView view, bool firstTimeShown) {
291    }
292
293    internal void HideView(IView view) {
294      if (InvokeRequired) Invoke((Action<IView>)HideView, view);
295      else {
296        this.Hide(view);
297        if (this.activeView == view)
298          this.ActiveView = null;
299        this.OnViewHidden(view);
300      }
301    }
302
303    protected virtual void Hide(IView view) {
304    }
305
306    private void ChildFormClosed(object sender, FormClosedEventArgs e) {
307      Form form = (Form)sender;
308      IView view = GetView(form);
309
310      view.Changed -= new EventHandler(View_Changed);
311      form.Activated -= new EventHandler(FormActivated);
312      form.FormClosed -= new FormClosedEventHandler(ChildFormClosed);
313
314      views.Remove(view);
315      this.OnViewClosed(view);
316      if (ActiveView == view)
317        ActiveView = null;
318    }
319
320    internal void CloseView(IView view) {
321      if (InvokeRequired) Invoke((Action<IView>)CloseView, view);
322      else if (views.ContainsKey(view)) {
323        this.views[view].Close();
324        this.OnViewClosed(view);
325      }
326    }
327
328    internal void CloseView(IView view, CloseReason closeReason) {
329      if (InvokeRequired) Invoke((Action<IView>)CloseView, view);
330      else if (views.ContainsKey(view)) {
331        ((View)view).CloseReason = closeReason;
332        this.CloseView(view);
333      }
334    }
335
336    public void CloseAllViews() {
337      foreach (IView view in views.Keys.ToArray())
338        CloseView(view);
339    }
340
341    public void CloseAllViews(CloseReason closeReason) {
342      foreach (IView view in views.Keys.ToArray())
343        CloseView(view, closeReason);
344    }
345    #endregion
346
347    #region progress views
348    private readonly Dictionary<IContent, IProgress> contentProgressLookup = new Dictionary<IContent, IProgress>();
349    private readonly Dictionary<Control, IProgress> viewProgressLookup = new Dictionary<Control, IProgress>();
350    private readonly List<ProgressView> progressViews = new List<ProgressView>();
351
352    public IProgress AddOperationProgressToContent(IContent content, string progressMessage, double? initialProgressValue = null, bool addToObjectGraphObjects = true) {
353      var progress = new Progress();
354      if (initialProgressValue.HasValue)
355        progress.Start(progressMessage, initialProgressValue.Value);
356      else
357        progress.Start(progressMessage);
358      AddOperationProgressToContent(content, progress, addToObjectGraphObjects);
359      return progress;
360    }
361    /// <summary>
362    /// Adds a <see cref="ProgressView"/> to the <see cref="ContentView"/>s showing the specified content.
363    /// </summary>
364    public void AddOperationProgressToContent(IContent content, IProgress progress, bool addToObjectGraphObjects = true) {
365      if (InvokeRequired) {
366        Invoke((Action<IContent, IProgress, bool>)AddOperationProgressToContent, content, progress, addToObjectGraphObjects);
367        return;
368      }
369      if (contentProgressLookup.ContainsKey(content))
370        throw new ArgumentException("A progress is already registered for the specified content.", "content");
371
372      var contentViews = views.Keys.OfType<ContentView>();
373      if (!contentViews.Any(v => v.Content == content))
374        throw new ArgumentException("The content is not displayed in a top-level view", "content");
375
376      if (addToObjectGraphObjects) {
377        var containedObjects = content.GetObjectGraphObjects();
378        contentViews = contentViews.Where(v => containedObjects.Contains(v.Content));
379      } else
380        contentViews = contentViews.Where(v => v.Content == content);
381
382      foreach (var contentView in contentViews) {
383        progressViews.Add(new ProgressView(contentView, progress));
384      }
385
386      contentProgressLookup[content] = progress;
387    }
388
389    public IProgress AddOperationProgressToView(Control control, string progressMessage, double? initialProgressValue = null) {
390      var progress = new Progress();
391      if (initialProgressValue.HasValue)
392        progress.Start(progressMessage, initialProgressValue.Value);
393      else
394        progress.Start(progressMessage);
395      AddOperationProgressToView(control, progress);
396      return progress;
397    }
398    /// <summary>
399    /// Adds a <see cref="ProgressView"/> to the specified view.
400    /// </summary>
401    public void AddOperationProgressToView(Control control, IProgress progress) {
402      if (InvokeRequired) {
403        Invoke((Action<Control, IProgress>)AddOperationProgressToView, control, progress);
404        return;
405      }
406      if (control == null) throw new ArgumentNullException("control", "The view must not be null.");
407      if (progress == null) throw new ArgumentNullException("progress", "The progress must not be null.");
408
409      IProgress oldProgress;
410      if (viewProgressLookup.TryGetValue(control, out oldProgress)) {
411        foreach (var progressView in progressViews.Where(v => v.Content == oldProgress).ToList()) {
412          progressView.Dispose();
413          progressViews.Remove(progressView);
414        }
415        viewProgressLookup.Remove(control);
416      }
417
418      progressViews.Add(new ProgressView(control, progress));
419      viewProgressLookup[control] = progress;
420    }
421
422    /// <summary>
423    /// Removes an existing <see cref="ProgressView"/> from the <see cref="ContentView"/>s showing the specified content.
424    /// </summary>
425    public void RemoveOperationProgressFromContent(IContent content, bool finishProgress = true) {
426      if (InvokeRequired) {
427        Invoke((Action<IContent, bool>)RemoveOperationProgressFromContent, content, finishProgress);
428        return;
429      }
430
431      IProgress progress;
432      if (!contentProgressLookup.TryGetValue(content, out progress))
433        throw new ArgumentException("No progress is registered for the specified content.", "content");
434
435      if (finishProgress) progress.Finish();
436      foreach (var progressView in progressViews.Where(v => v.Content == progress).ToList()) {
437        progressView.Dispose();
438        progressViews.Remove(progressView);
439      }
440      contentProgressLookup.Remove(content);
441
442    }
443
444    /// <summary>
445    /// Removes an existing <see cref="ProgressView"/> from the specified view.
446    /// </summary>
447    public void RemoveOperationProgressFromView(Control control, bool finishProgress = true) {
448      if (InvokeRequired) {
449        Invoke((Action<Control, bool>)RemoveOperationProgressFromView, control, finishProgress);
450        return;
451      }
452
453      IProgress progress;
454      if (!viewProgressLookup.TryGetValue(control, out progress))
455        throw new ArgumentException("No progress is registered for the specified control.", "control");
456
457      if (finishProgress) progress.Finish();
458      foreach (var progressView in progressViews.Where(v => v.Content == progress).ToList()) {
459        progressView.Dispose();
460        progressViews.Remove(progressView);
461      }
462      viewProgressLookup.Remove(control);
463    }
464    #endregion
465
466    #region create menu and toolbar
467    private void CreateGUI() {
468      if (userInterfaceItemType != null) {
469        IEnumerable<object> allUserInterfaceItems = ApplicationManager.Manager.GetInstances(userInterfaceItemType);
470
471        IEnumerable<IPositionableUserInterfaceItem> toolStripMenuItems =
472          from mi in allUserInterfaceItems
473          where (mi is IPositionableUserInterfaceItem) &&
474                (mi is IMenuItem || mi is IMenuSeparatorItem)
475          orderby ((IPositionableUserInterfaceItem)mi).Position
476          select (IPositionableUserInterfaceItem)mi;
477
478        foreach (IPositionableUserInterfaceItem menuItem in toolStripMenuItems) {
479          if (menuItem is IMenuItem)
480            AddToolStripMenuItem((IMenuItem)menuItem);
481          else if (menuItem is IMenuSeparatorItem)
482            AddToolStripMenuItem((IMenuSeparatorItem)menuItem);
483        }
484
485        IEnumerable<IPositionableUserInterfaceItem> toolStripButtonItems =
486          from bi in allUserInterfaceItems
487          where (bi is IPositionableUserInterfaceItem) &&
488                (bi is IToolBarItem || bi is IToolBarSeparatorItem)
489          orderby ((IPositionableUserInterfaceItem)bi).Position
490          select (IPositionableUserInterfaceItem)bi;
491
492        foreach (IPositionableUserInterfaceItem toolStripButtonItem in toolStripButtonItems) {
493          if (toolStripButtonItem is IToolBarItem)
494            AddToolStripButtonItem((IToolBarItem)toolStripButtonItem);
495          else if (toolStripButtonItem is IToolBarSeparatorItem)
496            AddToolStripButtonItem((IToolBarSeparatorItem)toolStripButtonItem);
497        }
498
499      }
500      this.AdditionalCreationOfGuiElements();
501
502      if (menuStrip.Items.Count == 0) menuStrip.Visible = false;
503      if (toolStrip.Items.Count == 0) toolStrip.Visible = false;
504    }
505
506    protected virtual void AdditionalCreationOfGuiElements() {
507    }
508
509    private void AddToolStripMenuItem(IMenuItem menuItem) {
510      ToolStripMenuItem item = new ToolStripMenuItem();
511      this.SetToolStripItemProperties(item, menuItem);
512      this.InsertItem(menuItem.Structure, typeof(ToolStripMenuItem), item, menuStrip.Items);
513      if (menuItem is MenuItem) {
514        MenuItem menuItemBase = (MenuItem)menuItem;
515        menuItemBase.ToolStripItem = item;
516        item.ShortcutKeys = menuItemBase.ShortCutKeys;
517        item.DisplayStyle = menuItemBase.ToolStripItemDisplayStyle;
518      }
519    }
520
521    private void AddToolStripMenuItem(IMenuSeparatorItem menuItem) {
522      this.InsertItem(menuItem.Structure, typeof(ToolStripMenuItem), new ToolStripSeparator(), menuStrip.Items);
523    }
524
525    private void AddToolStripButtonItem(IToolBarItem buttonItem) {
526      ToolStripItem item = new ToolStripButton();
527      if (buttonItem is ToolBarItem) {
528        ToolBarItem buttonItemBase = (ToolBarItem)buttonItem;
529        if (buttonItemBase.IsDropDownButton)
530          item = new ToolStripDropDownButton();
531
532        item.DisplayStyle = buttonItemBase.ToolStripItemDisplayStyle;
533        buttonItemBase.ToolStripItem = item;
534      }
535
536      this.SetToolStripItemProperties(item, buttonItem);
537      this.InsertItem(buttonItem.Structure, typeof(ToolStripDropDownButton), item, toolStrip.Items);
538    }
539
540    private void AddToolStripButtonItem(IToolBarSeparatorItem buttonItem) {
541      this.InsertItem(buttonItem.Structure, typeof(ToolStripDropDownButton), new ToolStripSeparator(), toolStrip.Items);
542    }
543
544    private void InsertItem(IEnumerable<string> structure, Type t, ToolStripItem item, ToolStripItemCollection parentItems) {
545      ToolStripDropDownItem parent = null;
546      foreach (string s in structure) {
547        if (parentItems.ContainsKey(s))
548          parent = (ToolStripDropDownItem)parentItems[s];
549        else {
550          parent = (ToolStripDropDownItem)Activator.CreateInstance(t, s, null, null, s); ;
551          parentItems.Add(parent);
552        }
553        parentItems = parent.DropDownItems;
554      }
555      parentItems.Add(item);
556    }
557
558    private void SetToolStripItemProperties(ToolStripItem toolStripItem, IActionUserInterfaceItem userInterfaceItem) {
559      toolStripItem.Name = userInterfaceItem.Name;
560      toolStripItem.Text = userInterfaceItem.Name;
561      toolStripItem.ToolTipText = userInterfaceItem.ToolTipText;
562      toolStripItem.Tag = userInterfaceItem;
563      toolStripItem.Image = userInterfaceItem.Image;
564      toolStripItem.Click += new EventHandler(ToolStripItemClicked);
565      this.userInterfaceItems.Add(userInterfaceItem);
566    }
567
568    private void ToolStripItemClicked(object sender, EventArgs e) {
569      System.Windows.Forms.ToolStripItem item = (System.Windows.Forms.ToolStripItem)sender;
570      try {
571        ((IActionUserInterfaceItem)item.Tag).Execute();
572      } catch (Exception ex) {
573        ErrorHandling.ShowErrorDialog((Control)MainFormManager.MainForm, ex);
574      }
575    }
576    #endregion
577
578    #region Cursor Handling
579    public void SetAppStartingCursor() {
580      if (InvokeRequired)
581        Invoke(new Action(SetAppStartingCursor));
582      else {
583        appStartingCursors++;
584        SetCursor();
585      }
586    }
587    public void ResetAppStartingCursor() {
588      if (InvokeRequired)
589        Invoke(new Action(ResetAppStartingCursor));
590      else {
591        appStartingCursors--;
592        SetCursor();
593      }
594    }
595    public void SetWaitCursor() {
596      if (InvokeRequired)
597        Invoke(new Action(SetWaitCursor));
598      else {
599        waitingCursors++;
600        SetCursor();
601      }
602    }
603    public void ResetWaitCursor() {
604      if (InvokeRequired)
605        Invoke(new Action(ResetWaitCursor));
606      else {
607        waitingCursors--;
608        SetCursor();
609      }
610    }
611    private void SetCursor() {
612      if (waitingCursors > 0) Cursor = Cursors.WaitCursor;
613      else if (appStartingCursors > 0) Cursor = Cursors.AppStarting;
614      else Cursor = Cursors.Default;
615    }
616    #endregion
617  }
618}
Note: See TracBrowser for help on using the repository browser.