Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Core.Views/3.3/ScopeView.cs @ 2818

Last change on this file since 2818 was 2818, checked in by swagner, 14 years ago

Operator architecture refactoring (#95)

  • corrected several bugs in order to get SGA working
File size: 11.0 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  [Content(typeof(Scope), true)]
33  [Content(typeof(IScope), false)]
34  public sealed partial class ScopeView : ItemView {
35    private Dictionary<IScope, TreeNode> scopeNodeTable;
36    private Dictionary<ScopeList, IScope> subScopesScopeTable;
37
38    /// <summary>
39    /// Gets or sets the scope to represent visually.
40    /// </summary>
41    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
42    /// No own data storage present.</remarks>
43    public new IScope Content {
44      get { return (IScope)base.Content; }
45      set { base.Content = value; }
46    }
47
48    /// <summary>
49    /// Initializes a new instance of <see cref="ScopeView"/> with caption "Scope" and
50    /// property <see cref="AutomaticUpdating"/> set to <c>false</c>.
51    /// </summary>
52    public ScopeView() {
53      InitializeComponent();
54      Caption = "Scope";
55      scopeNodeTable = new Dictionary<IScope, TreeNode>();
56      subScopesScopeTable = new Dictionary<ScopeList, IScope>();
57
58    }
59    /// <summary>
60    /// Initializes a new instance of <see cref="ScopeView"/> with the given <paramref name="scope"/>.
61    /// </summary>
62    /// <remarks>Calls <see cref="ScopeView()"/>.</remarks>
63    /// <param name="scope">The scope to represent visually.</param>
64    public ScopeView(IScope content)
65      : this() {
66      Content = content;
67    }
68
69    /// <summary>
70    /// Updates all controls with the latest data of the model.
71    /// </summary>
72    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
73    protected override void OnContentChanged() {
74      base.OnContentChanged();
75      if (scopesTreeView.Nodes.Count > 0) {
76        RemoveTreeNode(scopesTreeView.Nodes[0]);
77        scopesTreeView.Nodes.Clear();
78      }
79      variableCollectionView.Content = null;
80      variableCollectionView.Enabled = false;
81      if (Content == null) {
82        Caption = "Scope";
83        scopesTreeView.Enabled = false;
84      } else {
85        Caption = Content.Name + " (" + Content.GetType().Name + ")";
86        scopesTreeView.Enabled = true;
87        scopesTreeView.Nodes.Add(CreateTreeNode(Content));
88      }
89    }
90
91    private TreeNode CreateTreeNode(IScope scope) {
92      TreeNode node = new TreeNode();
93      node.Text = scope.Name;
94      node.Tag = scope;
95
96      scopeNodeTable.Add(scope, node);
97      scope.NameChanged += new EventHandler(Scope_NameChanged);
98      scope.SubScopes.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsAdded);
99      scope.SubScopes.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsRemoved);
100      scope.SubScopes.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced);
101      scope.SubScopes.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsMoved);
102      scope.SubScopes.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset);
103      subScopesScopeTable.Add(scope.SubScopes, scope);
104      if (scope.SubScopes.Count > 0)
105        node.Nodes.Add(new TreeNode());
106      return node;
107    }
108
109    private void RemoveTreeNode(TreeNode node) {
110      foreach (TreeNode child in node.Nodes)
111        RemoveTreeNode(child);
112
113      IScope scope = node.Tag as IScope;
114      if (scope != null) {
115        scopeNodeTable.Remove(scope);
116        scope.NameChanged -= new EventHandler(Scope_NameChanged);
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
126    #region TreeView Events
127    private void scopesTreeView_MouseDown(object sender, MouseEventArgs e) {
128      TreeNode node = scopesTreeView.GetNodeAt(e.X, e.Y);
129      if ((node != null) && (node.Tag is IScope)) {
130        variableCollectionView.Content = ((IScope)node.Tag).Variables;
131        variableCollectionView.Enabled = true;
132      } else {
133        variableCollectionView.Content = null;
134        variableCollectionView.Enabled = false;
135        if (node == null) scopesTreeView.SelectedNode = null;
136      }
137    }
138    private void scopesTreeView_BeforeExpand(object sender, TreeViewCancelEventArgs e) {
139      TreeNode node = e.Node;
140      IScope scope = (IScope)node.Tag;
141
142      node.Nodes.Clear();
143      for (int i = 0; i < scope.SubScopes.Count; i++)
144        node.Nodes.Add(CreateTreeNode(scope.SubScopes[i]));
145    }
146    private void scopesTreeView_AfterCollapse(object sender, System.Windows.Forms.TreeViewEventArgs e) {
147      TreeNode node = e.Node;
148      IScope scope = (IScope)node.Tag;
149
150      if (node.Nodes.Count > 0) {
151        for (int i = 0; i < node.Nodes.Count; i++)
152          RemoveTreeNode(node.Nodes[i]);
153        node.Nodes.Clear();
154        node.Nodes.Add(new TreeNode());
155      }
156    }
157    private void scopesTreeView_ItemDrag(object sender, ItemDragEventArgs e) {
158      TreeNode node = (TreeNode)e.Item;
159      IScope scope = node.Tag as IScope;
160      if (scope != null) {
161        DataObject data = new DataObject();
162        data.SetData("Scope", scope);
163        data.SetData("DragSource", scopesTreeView);
164        DoDragDrop(data, DragDropEffects.Copy);
165      }
166    }
167    #endregion
168
169    #region Scope 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        scopeNodeTable[scope].Text = scope.Name;
176      }
177    }
178    #endregion
179
180    #region SubScopes Events
181    private void SubScopes_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
182      if (InvokeRequired)
183        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsAdded), sender, e);
184      else {
185        IScope parentScope = subScopesScopeTable[(ScopeList)sender];
186        TreeNode parentNode = scopeNodeTable[parentScope];
187        if (parentNode.IsExpanded) {
188          foreach (IndexedItem<IScope> item in e.Items) {
189            TreeNode node = CreateTreeNode(item.Value);
190            parentNode.Nodes.Insert(item.Index, node);
191          }
192        } else if (parentNode.Nodes.Count == 0) {
193          parentNode.Nodes.Add(new TreeNode());
194        }
195      }
196    }
197    private void SubScopes_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
198      if (InvokeRequired)
199        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsRemoved), sender, e);
200      else {
201        IScope parentScope = subScopesScopeTable[(ScopeList)sender];
202        TreeNode parentNode = scopeNodeTable[parentScope];
203        if (parentNode.IsExpanded) {
204          foreach (IndexedItem<IScope> item in e.Items) {
205            TreeNode node = scopeNodeTable[item.Value];
206            RemoveTreeNode(node);
207            node.Remove();
208          }
209        } else if (parentScope.SubScopes.Count == 0) {
210          parentNode.Nodes.Clear();
211        }
212      }
213    }
214    private void SubScopes_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
215      if (InvokeRequired)
216        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced), sender, e);
217      else {
218        IScope parentScope = subScopesScopeTable[(ScopeList)sender];
219        TreeNode parentNode = scopeNodeTable[parentScope];
220        if (parentNode.IsExpanded) {
221          foreach (IndexedItem<IScope> item in e.Items) {
222            TreeNode node = parentNode.Nodes[item.Index];
223            RemoveTreeNode(node);
224            node.Remove();
225            node = CreateTreeNode(item.Value);
226            parentNode.Nodes.Insert(item.Index, node);
227          }
228        }
229      }
230    }
231    private void SubScopes_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
232      if (InvokeRequired)
233        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsMoved), sender, e);
234      else {
235        IScope parentScope = subScopesScopeTable[(ScopeList)sender];
236        TreeNode parentNode = scopeNodeTable[parentScope];
237        if (parentNode.IsExpanded) {
238          parentNode.Nodes.Clear();
239          foreach (IndexedItem<IScope> item in e.Items)
240            parentNode.Nodes.Insert(item.Index, scopeNodeTable[item.Value]);
241        }
242      }
243    }
244    private void SubScopes_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
245      if (InvokeRequired)
246        Invoke(new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset), sender, e);
247      else {
248        IScope parentScope = subScopesScopeTable[(ScopeList)sender];
249        TreeNode parentNode = scopeNodeTable[parentScope];
250        if (parentNode.IsExpanded) {
251          foreach (TreeNode node in parentNode.Nodes)
252            RemoveTreeNode(node);
253          parentNode.Nodes.Clear();
254          foreach (IndexedItem<IScope> item in e.Items) {
255            TreeNode node = CreateTreeNode(item.Value);
256            parentNode.Nodes.Insert(item.Index, node);
257          }
258        } else {
259          parentNode.Nodes.Clear();
260          if (parentScope.SubScopes.Count > 0)
261            parentNode.Nodes.Add(new TreeNode());
262        }
263      }
264    }
265    #endregion
266  }
267}
Note: See TracBrowser for help on using the repository browser.