Free cookie consent management tool by TermsFeed Policy Generator

source: tags/3.3.0/HeuristicLab.Core.Views/3.3/ScopeView.cs

Last change on this file was 3764, checked in by mkommend, 14 years ago

adapted view captions (ticket #893)
File size: 12.7 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.Windows.Forms;
25using HeuristicLab.Collections;
26using HeuristicLab.MainForm;
27
28namespace HeuristicLab.Core.Views {
29  /// <summary>
30  /// The visual represenation of <see cref="Scope"/>.
31  /// </summary>
32  [View("Scope View")]
33  [Content(typeof(Scope), true)]
34  [Content(typeof(IScope), false)]
35  public sealed partial class ScopeView : ItemView {
36    private Dictionary<IScope, TreeNode> scopeNodeTable;
37    private Dictionary<ScopeList, IScope> subScopesScopeTable;
38
39    /// <summary>
40    /// Gets or sets the scope to represent visually.
41    /// </summary>
42    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
43    /// No own data storage present.</remarks>
44    public new IScope Content {
45      get { return (IScope)base.Content; }
46      set { base.Content = value; }
47    }
48
49    /// <summary>
50    /// Initializes a new instance of <see cref="ScopeView"/> with caption "Scope" and
51    /// property <see cref="AutomaticUpdating"/> set to <c>false</c>.
52    /// </summary>
53    public ScopeView() {
54      InitializeComponent();
55      scopeNodeTable = new Dictionary<IScope, TreeNode>();
56      subScopesScopeTable = new Dictionary<ScopeList, IScope>();
57    }
58
59    /// <summary>
60    /// Updates all controls with the latest data of the model.
61    /// </summary>
62    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
63    protected override void OnContentChanged() {
64      base.OnContentChanged();
65      if (scopesTreeView.Nodes.Count > 0)
66        ClearTreeNode(scopesTreeView.Nodes[0]);
67      scopesTreeView.Nodes.Clear();
68      variableCollectionView.Content = null;
69      if (Content != null) {
70        scopesTreeView.Nodes.Add(CreateTreeNode(Content));
71      }
72      SetEnabledStateOfControls();
73    }
74
75    protected override void OnReadOnlyChanged() {
76      base.OnReadOnlyChanged();
77      SetEnabledStateOfControls();
78    }
79
80    private void SetEnabledStateOfControls() {
81      scopesTreeView.Enabled = Content != null;
82      variableCollectionView.Enabled = scopesTreeView.SelectedNode != null;
83    }
84
85    #region TreeNode Management
86    private TreeNode CreateTreeNode(IScope scope) {
87      TreeNode node = new TreeNode();
88      node.Text = scope.Name;
89      node.Tag = scope;
90
91      scopeNodeTable.Add(scope, node);
92      scope.NameChanged += new EventHandler(Scope_NameChanged);
93      subScopesScopeTable.Add(scope.SubScopes, scope);
94      scope.SubScopes.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsAdded);
95      scope.SubScopes.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsRemoved);
96      scope.SubScopes.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced);
97      scope.SubScopes.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsMoved);
98      scope.SubScopes.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset);
99      if (scope.SubScopes.Count > 0)
100        node.Nodes.Add(new TreeNode());
101      return node;
102    }
103
104    private void ClearTreeNode(TreeNode node) {
105      if (scopesTreeView.SelectedNode == node) {
106        scopesTreeView.SelectedNode = null;
107        UpdateVariables();
108      }
109
110      foreach (TreeNode child in node.Nodes)
111        ClearTreeNode(child);
112
113      IScope scope = node.Tag as IScope;
114      if (scope != null) {
115        scope.NameChanged -= new EventHandler(Scope_NameChanged);
116        scopeNodeTable.Remove(scope);
117        scope.SubScopes.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsAdded);
118        scope.SubScopes.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsRemoved);
119        scope.SubScopes.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced);
120        scope.SubScopes.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsMoved);
121        scope.SubScopes.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset);
122        subScopesScopeTable.Remove(scope.SubScopes);
123      }
124    }
125    #endregion
126
127    #region TreeView Events
128    private void scopesTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
129      UpdateVariables();
130    }
131    private void scopesTreeView_MouseDown(object sender, MouseEventArgs e) {
132      TreeNode node = scopesTreeView.GetNodeAt(e.X, e.Y);
133      scopesTreeView.SelectedNode = node;
134      UpdateVariables();
135    }
136    private void scopesTreeView_BeforeExpand(object sender, TreeViewCancelEventArgs e) {
137      TreeNode node = e.Node;
138      IScope scope = (IScope)node.Tag;
139
140      node.Nodes.Clear();
141      for (int i = 0; i < scope.SubScopes.Count; i++)
142        node.Nodes.Add(CreateTreeNode(scope.SubScopes[i]));
143    }
144    private void scopesTreeView_AfterCollapse(object sender, System.Windows.Forms.TreeViewEventArgs e) {
145      TreeNode node = e.Node;
146      IScope scope = (IScope)node.Tag;
147
148      if (node.Nodes.Count > 0) {
149        for (int i = 0; i < node.Nodes.Count; i++)
150          ClearTreeNode(node.Nodes[i]);
151        node.Nodes.Clear();
152        node.Nodes.Add(new TreeNode());
153      }
154    }
155    private void scopesTreeView_ItemDrag(object sender, ItemDragEventArgs e) {
156      if (!Locked) {
157        TreeNode node = (TreeNode)e.Item;
158        IScope scope = node.Tag as IScope;
159        if (scope != null) {
160          DataObject data = new DataObject();
161          data.SetData("Type", scope.GetType());
162          data.SetData("Value", scope);
163          DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link);
164        }
165      }
166    }
167    #endregion
168
169    #region Content Events
170    private void Scope_NameChanged(object sender, EventArgs e) {
171      if (InvokeRequired)
172        Invoke(new EventHandler(Scope_NameChanged), sender, e);
173      else {
174        IScope scope = (IScope)sender;
175        TreeNode node = null;
176        scopeNodeTable.TryGetValue(scope, out node);
177        if (node != null) node.Text = scope.Name;
178      }
179    }
180    private void SubScopes_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
181      if (InvokeRequired)
182        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsAdded), sender, e);
183      else {
184        IScope parentScope = null;
185        subScopesScopeTable.TryGetValue((ScopeList)sender, out parentScope);
186        if (parentScope != null) {
187          TreeNode parentNode = null;
188          scopeNodeTable.TryGetValue(parentScope, out parentNode);
189          if (parentNode != null) {
190            scopesTreeView.BeginUpdate();
191            if (parentNode.IsExpanded) {
192              foreach (IndexedItem<IScope> item in e.Items) {
193                TreeNode node = CreateTreeNode(item.Value);
194                parentNode.Nodes.Insert(item.Index, node);
195              }
196            } else if (parentNode.Nodes.Count == 0) {
197              parentNode.Nodes.Add(new TreeNode());
198            }
199            scopesTreeView.EndUpdate();
200          }
201        }
202      }
203    }
204    private void SubScopes_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
205      if (InvokeRequired)
206        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsRemoved), sender, e);
207      else {
208        IScope parentScope = null;
209        subScopesScopeTable.TryGetValue((ScopeList)sender, out parentScope);
210        if (parentScope != null) {
211          TreeNode parentNode = null;
212          scopeNodeTable.TryGetValue(parentScope, out parentNode);
213          if (parentNode != null) {
214            scopesTreeView.BeginUpdate();
215            if (parentNode.IsExpanded) {
216              foreach (IndexedItem<IScope> item in e.Items) {
217                TreeNode node = scopeNodeTable[item.Value];
218                ClearTreeNode(node);
219                node.Remove();
220              }
221            } else if (parentScope.SubScopes.Count == 0) {
222              parentNode.Nodes.Clear();
223            }
224            scopesTreeView.EndUpdate();
225          }
226        }
227      }
228    }
229    private void SubScopes_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
230      if (InvokeRequired)
231        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced), sender, e);
232      else {
233        IScope parentScope = null;
234        subScopesScopeTable.TryGetValue((ScopeList)sender, out parentScope);
235        if (parentScope != null) {
236          TreeNode parentNode = null;
237          scopeNodeTable.TryGetValue(parentScope, out parentNode);
238          if (parentNode != null) {
239            scopesTreeView.BeginUpdate();
240            if (parentNode.IsExpanded) {
241              foreach (IndexedItem<IScope> item in e.Items) {
242                TreeNode node = parentNode.Nodes[item.Index];
243                ClearTreeNode(node);
244                node.Remove();
245                node = CreateTreeNode(item.Value);
246                parentNode.Nodes.Insert(item.Index, node);
247              }
248              scopesTreeView.EndUpdate();
249            }
250          }
251        }
252      }
253    }
254    private void SubScopes_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
255      if (InvokeRequired)
256        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsMoved), sender, e);
257      else {
258        IScope parentScope = null;
259        subScopesScopeTable.TryGetValue((ScopeList)sender, out parentScope);
260        if (parentScope != null) {
261          TreeNode parentNode = null;
262          scopeNodeTable.TryGetValue(parentScope, out parentNode);
263          if (parentNode != null) {
264            scopesTreeView.BeginUpdate();
265            if (parentNode.IsExpanded) {
266              parentNode.Nodes.Clear();
267              foreach (IndexedItem<IScope> item in e.Items)
268                parentNode.Nodes.Insert(item.Index, scopeNodeTable[item.Value]);
269            }
270            scopesTreeView.EndUpdate();
271          }
272        }
273      }
274    }
275    private void SubScopes_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
276      if (InvokeRequired)
277        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset), sender, e);
278      else {
279        IScope parentScope = null;
280        subScopesScopeTable.TryGetValue((ScopeList)sender, out parentScope);
281        if (parentScope != null) {
282          TreeNode parentNode = null;
283          scopeNodeTable.TryGetValue(parentScope, out parentNode);
284          if (parentNode != null) {
285            scopesTreeView.BeginUpdate();
286            if (parentNode.IsExpanded) {
287              foreach (TreeNode node in parentNode.Nodes)
288                ClearTreeNode(node);
289              parentNode.Nodes.Clear();
290              foreach (IndexedItem<IScope> item in e.Items) {
291                TreeNode node = CreateTreeNode(item.Value);
292                parentNode.Nodes.Insert(item.Index, node);
293              }
294            } else {
295              parentNode.Nodes.Clear();
296              if (parentScope.SubScopes.Count > 0)
297                parentNode.Nodes.Add(new TreeNode());
298            }
299            scopesTreeView.EndUpdate();
300          }
301        }
302      }
303    }
304    #endregion
305
306    #region Helpers
307    private void UpdateVariables() {
308      if (scopesTreeView.SelectedNode == null) {
309        variableCollectionView.Content = null;
310        variableCollectionView.Enabled = false;
311      } else {
312        variableCollectionView.Enabled = true;
313        variableCollectionView.Content = ((IScope)scopesTreeView.SelectedNode.Tag).Variables;
314      }
315    }
316    #endregion
317  }
318}
Note: See TracBrowser for help on using the repository browser.