Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.MainForm.WindowsForms/3.2/MainForm.cs @ 2913

Last change on this file since 2913 was 2793, checked in by swagner, 15 years ago

Operator architecture refactoring (#95)

  • replaced new EventArgs() by EventArgs.Empty
File size: 12.3 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2010 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.ComponentModel;
25using System.Data;
26using System.Drawing;
27using System.Linq;
28using System.Text;
29using System.Windows.Forms;
30
31using HeuristicLab.PluginInfrastructure;
32using System.Collections;
33
34namespace HeuristicLab.MainForm.WindowsForms {
35  public partial class MainForm : Form, IMainForm {
36    private bool initialized;
37
38    protected MainForm()
39      : base() {
40      InitializeComponent();
41      this.views = new Dictionary<IView, Form>();
42      this.userInterfaceItems = new List<IUserInterfaceItem>();
43      this.initialized = false;
44    }
45
46    protected MainForm(Type userInterfaceItemType)
47      : this() {
48      this.userInterfaceItemType = userInterfaceItemType;
49    }
50
51    #region properties
52    public string Title {
53      get { return this.Text; }
54      set {
55        if (InvokeRequired) {
56          Action<string> action = delegate(string s) { this.Title = s; };
57          Invoke(action, value);
58        } else
59          this.Text = value;
60      }
61    }
62
63    public override Cursor Cursor {
64      get { return base.Cursor; }
65      set {
66        if (InvokeRequired) {
67          Action<Cursor> action = delegate(Cursor c) { this.Cursor = c; };
68          Invoke(action, value);
69        } else
70          base.Cursor = value;
71      }
72    }
73
74    private Type userInterfaceItemType;
75    public Type UserInterfaceItemType {
76      get { return this.userInterfaceItemType; }
77    }
78
79    private Dictionary<IView, Form> views;
80    public IEnumerable<IView> Views {
81      get { return views.Keys; }
82    }
83
84    private IView activeView;
85    public IView ActiveView {
86      get { return this.activeView; }
87      protected set {
88        if (this.activeView != value && (value != null || this.views.Keys.All(v => !v.IsShown))) {
89          if (InvokeRequired) {
90            Action<IView> action = delegate(IView activeView) { this.ActiveView = activeView; };
91            Invoke(action, value);
92          } else {
93            this.activeView = value;
94            OnActiveViewChanged();
95          }
96        }
97      }
98    }
99
100    private List<IUserInterfaceItem> userInterfaceItems;
101    protected IEnumerable<IUserInterfaceItem> UserInterfaceItems {
102      get { return this.userInterfaceItems; }
103    }
104    #endregion
105
106    #region events
107    public event EventHandler ActiveViewChanged;
108    protected virtual void OnActiveViewChanged() {
109      if (InvokeRequired)
110        Invoke((MethodInvoker)OnActiveViewChanged);
111      else if (ActiveViewChanged != null)
112        ActiveViewChanged(this, EventArgs.Empty);
113    }
114
115    public event EventHandler<ViewEventArgs> ViewClosed;
116    protected virtual void OnViewClosed(IView view) {
117      if (InvokeRequired) Invoke((Action<IView>)OnViewClosed, view);
118      else if (this.ViewClosed != null) {
119        this.ViewClosed(this, new ViewEventArgs(view));
120      }
121    }
122
123    public event EventHandler<ViewShownEventArgs> ViewShown;
124    protected virtual void OnViewShown(IView view, bool firstTimeShown) {
125      if (InvokeRequired) Invoke((Action<IView, bool>)OnViewShown, view, firstTimeShown);
126      else if (this.ViewShown != null) {
127        this.ViewShown(this, new ViewShownEventArgs(view, firstTimeShown));
128      }
129    }
130
131    public event EventHandler<ViewEventArgs> ViewHidden;
132    protected virtual void OnViewHidden(IView view) {
133      if (InvokeRequired) Invoke((Action<IView>)OnViewHidden, view);
134      else if (this.ViewHidden != null) {
135        this.ViewHidden(this, new ViewEventArgs(view));
136      }
137    }
138
139    public event EventHandler Changed;
140    protected void FireMainFormChanged() {
141      if (InvokeRequired)
142        Invoke((MethodInvoker)FireMainFormChanged);
143      else if (Changed != null)
144        Changed(this, EventArgs.Empty);
145    }
146
147    private void MainFormBase_Load(object sender, EventArgs e) {
148      if (!DesignMode) {
149        MainFormManager.RegisterMainForm(this);
150        if (!this.initialized) {
151          this.initialized = true;
152          this.OnInitialized(EventArgs.Empty);
153        }
154        this.CreateGUI();
155      }
156    }
157
158    protected virtual void OnInitialized(EventArgs e) {
159    }
160
161    private void ChildFormClosed(object sender, FormClosedEventArgs e) {
162      Form form = (Form)sender;
163      IView view = GetView(form);
164
165      form.Activated -= new EventHandler(FormActivated);
166      form.FormClosed -= new FormClosedEventHandler(ChildFormClosed);
167
168      views.Remove(view);
169      this.OnViewClosed(view);
170      if (ActiveView == view)
171        ActiveView = null;
172    }
173
174    private void FormActivated(object sender, EventArgs e) {
175      this.ActiveView = GetView((Form)sender);
176    }
177    #endregion
178
179    #region create, get, show, hide, close views
180    protected virtual Form CreateForm(IView view) {
181      throw new NotImplementedException("CreateForm must be implemented in subclasses of MainFormBase.");
182    }
183
184    internal Form GetForm(IView view) {
185      if (views.ContainsKey(view))
186        return views[view];
187      return null;
188    }
189
190    internal IView GetView(Form form) {
191      return views.Where(x => x.Value == form).Single().Key;
192    }
193
194    internal void ShowView(IView view, bool firstTimeShown) {
195      if (InvokeRequired) Invoke((Action<IView, bool>)ShowView, view, firstTimeShown);
196      else {
197        if (firstTimeShown) {
198          Form form = CreateForm(view);
199          this.views[view] = form;
200          form.Activated += new EventHandler(FormActivated);
201          form.FormClosed += new FormClosedEventHandler(ChildFormClosed);
202        }
203        this.Show(view, firstTimeShown);
204        this.OnViewShown(view, firstTimeShown);
205      }
206    }
207
208    protected virtual void Show(IView view, bool firstTimeShown) {
209    }
210
211    internal void HideView(IView view) {
212      if (InvokeRequired) Invoke((Action<IView>)HideView, view);
213      else {
214        if (this.views.ContainsKey(view)) {
215          this.Hide(view);
216          if (this.activeView == view && views.All(v => !view.IsShown))
217            this.ActiveView = null;
218          this.OnViewHidden(view);
219        }
220      }
221    }
222
223    protected virtual void Hide(IView view) {
224    }
225
226    internal void CloseView(IView view) {
227      if (InvokeRequired) Invoke((Action<IView>)CloseView, view);
228      else {
229        if (this.views.ContainsKey(view)) {
230          this.views[view].Close();
231          this.OnViewClosed(view);
232        }
233      }
234    }
235
236    internal void CloseView(IView view, CloseReason closeReason) {
237      if (InvokeRequired) Invoke((Action<IView>)CloseView, view);
238      else {
239        if (this.views.ContainsKey(view)) {
240          ((View)view).closeReason = closeReason;
241          this.CloseView(view);
242        }
243      }
244    }
245
246    public void CloseAllViews() {
247      foreach (IView view in views.Keys.ToArray())
248        CloseView(view);
249    }
250
251    public void CloseAllViews(CloseReason closeReason) {
252      foreach (IView view in views.Keys.ToArray())
253        CloseView(view, closeReason);
254    }
255    #endregion
256
257    #region create menu and toolbar
258    private void CreateGUI() {
259      IEnumerable<object> allUserInterfaceItems = ApplicationManager.Manager.GetInstances(userInterfaceItemType);
260
261      IEnumerable<IPositionableUserInterfaceItem> toolStripMenuItems =
262        from mi in allUserInterfaceItems
263        where (mi is IPositionableUserInterfaceItem) &&
264              (mi is IMenuItem || mi is IMenuSeparatorItem)
265        orderby ((IPositionableUserInterfaceItem)mi).Position
266        select (IPositionableUserInterfaceItem)mi;
267
268      foreach (IPositionableUserInterfaceItem menuItem in toolStripMenuItems) {
269        if (menuItem is IMenuItem)
270          AddToolStripMenuItem((IMenuItem)menuItem);
271        else if (menuItem is IMenuSeparatorItem)
272          AddToolStripMenuItem((IMenuSeparatorItem)menuItem);
273      }
274
275      IEnumerable<IPositionableUserInterfaceItem> toolStripButtonItems =
276        from bi in allUserInterfaceItems
277        where (bi is IPositionableUserInterfaceItem) &&
278              (bi is IToolBarItem || bi is IToolBarSeparatorItem)
279        orderby ((IPositionableUserInterfaceItem)bi).Position
280        select (IPositionableUserInterfaceItem)bi;
281
282      foreach (IPositionableUserInterfaceItem toolStripButtonItem in toolStripButtonItems) {
283        if (toolStripButtonItem is IToolBarItem)
284          AddToolStripButtonItem((IToolBarItem)toolStripButtonItem);
285        else if (toolStripButtonItem is IToolBarSeparatorItem)
286          AddToolStripButtonItem((IToolBarSeparatorItem)toolStripButtonItem);
287      }
288
289      this.AdditionalCreationOfGuiElements();
290    }
291
292    protected virtual void AdditionalCreationOfGuiElements() {
293    }
294
295    private void AddToolStripMenuItem(IMenuItem menuItem) {
296      ToolStripMenuItem item = new ToolStripMenuItem();
297      this.SetToolStripItemProperties(item, menuItem);
298      if (menuItem is MenuItem) {
299        MenuItem menuItemBase = (MenuItem)menuItem;
300        menuItemBase.ToolStripItem = item;
301        item.ShortcutKeys = menuItemBase.ShortCutKeys;
302        item.DisplayStyle = menuItemBase.ToolStripItemDisplayStyle;
303      }
304      this.InsertItem(menuItem.Structure, typeof(ToolStripMenuItem), item, menuStrip.Items);
305    }
306
307    private void AddToolStripMenuItem(IMenuSeparatorItem menuItem) {
308      this.InsertItem(menuItem.Structure, typeof(ToolStripMenuItem), new ToolStripSeparator(), menuStrip.Items);
309    }
310
311    private void AddToolStripButtonItem(IToolBarItem buttonItem) {
312      ToolStripItem item = new ToolStripButton();
313      if (buttonItem is ToolBarItem) {
314        ToolBarItem buttonItemBase = (ToolBarItem)buttonItem;
315        if (buttonItemBase.IsDropDownButton)
316          item = new ToolStripDropDownButton();
317
318        item.DisplayStyle = buttonItemBase.ToolStripItemDisplayStyle;
319        buttonItemBase.ToolStripItem = item;
320      }
321
322      this.SetToolStripItemProperties(item, buttonItem);
323      this.InsertItem(buttonItem.Structure, typeof(ToolStripDropDownButton), item, toolStrip.Items);
324    }
325
326    private void AddToolStripButtonItem(IToolBarSeparatorItem buttonItem) {
327      this.InsertItem(buttonItem.Structure, typeof(ToolStripDropDownButton), new ToolStripSeparator(), toolStrip.Items);
328    }
329
330    private void InsertItem(IEnumerable<string> structure, Type t, ToolStripItem item, ToolStripItemCollection parentItems) {
331      ToolStripDropDownItem parent = null;
332      foreach (string s in structure) {
333        if (parentItems.ContainsKey(s))
334          parent = (ToolStripDropDownItem)parentItems[s];
335        else {
336          parent = (ToolStripDropDownItem)Activator.CreateInstance(t, s, null, null, s); ;
337          parentItems.Add(parent);
338        }
339        parentItems = parent.DropDownItems;
340      }
341      parentItems.Add(item);
342    }
343
344    private void SetToolStripItemProperties(ToolStripItem toolStripItem, IActionUserInterfaceItem userInterfaceItem) {
345      toolStripItem.Name = userInterfaceItem.Name;
346      toolStripItem.Text = userInterfaceItem.Name;
347      toolStripItem.ToolTipText = userInterfaceItem.ToolTipText;
348      toolStripItem.Tag = userInterfaceItem;
349      toolStripItem.Image = userInterfaceItem.Image;
350      toolStripItem.Click += new EventHandler(ToolStripItemClicked);
351      this.userInterfaceItems.Add(userInterfaceItem);
352    }
353
354    private void ToolStripItemClicked(object sender, EventArgs e) {
355      System.Windows.Forms.ToolStripItem item = (System.Windows.Forms.ToolStripItem)sender;
356      ((IActionUserInterfaceItem)item.Tag).Execute();
357    }
358    #endregion
359  }
360}
Note: See TracBrowser for help on using the repository browser.