source: stable/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.cs @ 13178

Last change on this file since 13178 was 13178, checked in by mkommend, 4 years ago

#2493: Merged r13143 into stable.

File size: 40.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 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;
24using System.Collections.Generic;
25using System.Drawing;
26using System.Linq;
27using System.Windows.Forms;
28using HeuristicLab.Collections;
29using HeuristicLab.Common;
30using HeuristicLab.Core;
31using HeuristicLab.Core.Views;
32using HeuristicLab.MainForm;
33using HeuristicLab.PluginInfrastructure;
34
35namespace HeuristicLab.Optimization.Views {
36  public sealed partial class ExperimentTreeView : ItemView {
37    private TypeSelectorDialog typeSelectorDialog;
38    private Dictionary<INamedItem, List<TreeNode>> treeNodeTagMapping;
39
40    public ExperimentTreeView() {
41      InitializeComponent();
42      treeNodeTagMapping = new Dictionary<INamedItem, List<TreeNode>>();
43    }
44
45    protected override void Dispose(bool disposing) {
46      if (disposing) {
47        if (typeSelectorDialog != null) typeSelectorDialog.Dispose();
48        if (components != null) components.Dispose();
49      }
50      base.Dispose(disposing);
51    }
52
53    #region necessary code to handle dock correctly regarding the expanded nodes
54    bool[] expandendedState;
55    protected override void OnHandleCreated(EventArgs e) {
56      base.OnHandleCreated(e);
57      if (expandendedState == null) return;
58      var nodes = IterateTreeNodes().ToList();
59      for (int i = 0; i < nodes.Count; i++)
60        if (expandendedState[i]) nodes[i].Expand();
61    }
62    protected override void OnHandleDestroyed(EventArgs e) {
63      base.OnHandleDestroyed(e);
64      var nodes = IterateTreeNodes().ToList();
65      expandendedState = new bool[nodes.Count];
66      for (int i = 0; i < nodes.Count; i++)
67        expandendedState[i] = nodes[i].IsExpanded;
68    }
69    #endregion
70
71    public new Experiment Content {
72      get { return (Experiment)base.Content; }
73      set { base.Content = value; }
74    }
75
76    #region events registration
77    protected override void RegisterContentEvents() {
78      base.RegisterContentEvents();
79      Content.ExecutionStateChanged += new EventHandler(Content_ExecutionStateChanged);
80      Content.Optimizers.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsAdded);
81      Content.Optimizers.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsMoved);
82      Content.Optimizers.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsRemoved);
83      Content.Optimizers.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsReplaced);
84      Content.Optimizers.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_CollectionReset);
85    }
86
87    protected override void DeregisterContentEvents() {
88      Content.ExecutionStateChanged -= new EventHandler(Content_ExecutionStateChanged);
89      Content.Optimizers.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsAdded);
90      Content.Optimizers.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsMoved);
91      Content.Optimizers.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsRemoved);
92      Content.Optimizers.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsReplaced);
93      Content.Optimizers.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_CollectionReset);
94      foreach (var optimizer in treeNodeTagMapping.Keys)
95        DeregisterNamedItemEvents(optimizer);
96      base.DeregisterContentEvents();
97    }
98
99    private void RegisterNamedItemEvents(INamedItem namedItem) {
100      namedItem.ToStringChanged += new EventHandler(namedItem_ToStringChanged);
101      namedItem.ItemImageChanged += new EventHandler(namedItem_ItemImageChanged);
102
103      var algorithm = namedItem as IAlgorithm;
104      var batchRun = namedItem as BatchRun;
105      var experiment = namedItem as Experiment;
106
107      if (algorithm != null) {
108        algorithm.Prepared += new EventHandler(algorithm_Prepared);
109        algorithm.ProblemChanged += new EventHandler(algorithm_ProblemChanged);
110      } else if (batchRun != null) {
111        batchRun.OptimizerChanged += new EventHandler(batchRun_OptimizerChanged);
112        batchRun.RepetetionsCounterChanged += new EventHandler(batchRun_RepetitionsCounterChanged);
113        batchRun.RepetitionsChanged += new EventHandler(batchRun_RepetitionsChanged);
114      } else if (experiment != null) {
115        experiment.Optimizers.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsAdded);
116        experiment.Optimizers.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsMoved);
117        experiment.Optimizers.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsRemoved);
118        experiment.Optimizers.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsReplaced);
119        experiment.Optimizers.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_CollectionReset);
120      }
121    }
122
123    private void DeregisterNamedItemEvents(INamedItem namedItem) {
124      namedItem.ToStringChanged -= new EventHandler(namedItem_ToStringChanged);
125      namedItem.ItemImageChanged -= new EventHandler(namedItem_ItemImageChanged);
126
127      var algorithm = namedItem as IAlgorithm;
128      var batchRun = namedItem as BatchRun;
129      var experiment = namedItem as Experiment;
130
131      if (algorithm != null) {
132        algorithm.Prepared -= new EventHandler(algorithm_Prepared);
133        algorithm.ProblemChanged -= new EventHandler(algorithm_ProblemChanged);
134      } else if (batchRun != null) {
135        batchRun.OptimizerChanged -= new EventHandler(batchRun_OptimizerChanged);
136        batchRun.RepetetionsCounterChanged -= new EventHandler(batchRun_RepetitionsCounterChanged);
137        batchRun.RepetitionsChanged += new EventHandler(batchRun_RepetitionsChanged);
138      } else if (experiment != null) {
139        experiment.Optimizers.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsAdded);
140        experiment.Optimizers.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsMoved);
141        experiment.Optimizers.ItemsRemoved -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsRemoved);
142        experiment.Optimizers.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsReplaced);
143        experiment.Optimizers.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_CollectionReset);
144      }
145    }
146    #endregion
147
148    protected override void OnContentChanged() {
149      base.OnContentChanged();
150      if (Content == null) {
151        treeView.Nodes.Clear();
152      } else {
153        UpdateOptimizerTreeView();
154        treeView.ExpandAll();
155      }
156    }
157
158    #region content events
159    private void Content_ExecutionStateChanged(object sender, EventArgs e) {
160      if (InvokeRequired) {
161        Invoke((Action<object, EventArgs>)Content_ExecutionStateChanged, sender, e);
162        return;
163      }
164      SetEnabledStateOfControls();
165    }
166
167    private void algorithm_Prepared(object sender, EventArgs e) {
168      var algorithm = (IAlgorithm)sender;
169      foreach (TreeNode node in treeNodeTagMapping[algorithm]) {
170        TreeNode resultsNode = node.Nodes.OfType<TreeNode>().Where(x => x.Tag is ResultCollection).Single();
171        if (detailsViewHost.Content == resultsNode.Tag)
172          detailsViewHost.Content = algorithm.Results;
173        resultsNode.Tag = algorithm.Results;
174      }
175    }
176
177    private void algorithm_ProblemChanged(object sender, EventArgs e) {
178      if (InvokeRequired) {
179        Invoke((Action<object, EventArgs>)algorithm_ProblemChanged, sender, e);
180        return;
181      }
182
183      var algorithm = (IAlgorithm)sender;
184      foreach (TreeNode node in treeNodeTagMapping[algorithm]) {
185        foreach (TreeNode childNode in node.Nodes.OfType<TreeNode>().ToList()) {
186          DisposeTreeNode(childNode);
187          childNode.Remove();
188        }
189        List<TreeNode> nodes;
190        foreach (TreeNode childNode in CreateAlgorithmChildNodes(algorithm)) {
191          node.Nodes.Add(childNode);
192          INamedItem namedItem = childNode.Tag as INamedItem;
193          if (namedItem != null) {
194            if (!treeNodeTagMapping.TryGetValue(namedItem, out nodes)) {
195              nodes = new List<TreeNode>();
196              treeNodeTagMapping.Add(namedItem, nodes);
197              RegisterNamedItemEvents(namedItem);
198            }
199            nodes.Add(childNode);
200          }
201        }
202
203        node.Expand();
204      }
205
206      RebuildImageList();
207      UpdateDetailsViewHost();
208    }
209
210    private void batchRun_OptimizerChanged(object sender, EventArgs e) {
211      if (InvokeRequired) {
212        Invoke((Action<object, EventArgs>)batchRun_OptimizerChanged, sender, e);
213        return;
214      }
215      var batchRun = (BatchRun)sender;
216      foreach (TreeNode node in treeNodeTagMapping[batchRun]) {
217        foreach (TreeNode childNode in node.Nodes.OfType<TreeNode>().ToList()) {
218          DisposeTreeNode(childNode);
219          childNode.Remove();
220        }
221
222        if (batchRun.Optimizer != null) {
223          UpdateChildTreeNodes(node.Nodes, batchRun);
224          node.Expand();
225        }
226      }
227      RebuildImageList();
228      UpdateDetailsViewHost();
229    }
230
231    private void batchRun_RepetitionsCounterChanged(object sender, EventArgs e) {
232      namedItem_ToStringChanged(sender, e);
233    }
234    private void batchRun_RepetitionsChanged(object sender, EventArgs e) {
235      namedItem_ToStringChanged(sender, e);
236    }
237
238    private void Optimizers_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>> e) {
239      if (InvokeRequired) {
240        Invoke((Action<object, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>>>)Optimizers_ItemsAdded, sender, e);
241        return;
242      }
243
244      var optimizerList = (OptimizerList)sender;
245      IEnumerable<TreeNodeCollection> parentNodes;
246      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
247      else {
248        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
249        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
250      }
251
252      foreach (TreeNodeCollection parentNode in parentNodes) {
253        foreach (var childOptimizer in e.Items) {
254          TreeNode childNode = CreateTreeNode(childOptimizer.Value);
255          UpdateChildTreeNodes(childNode.Nodes, childOptimizer.Value);
256          parentNode.Insert(childOptimizer.Index, childNode);
257          childNode.ExpandAll();
258          if (childNode.Parent != null) childNode.Parent.ExpandAll();
259        }
260      }
261      RebuildImageList();
262    }
263    private void Optimizers_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>> e) {
264      if (InvokeRequired) {
265        Invoke((Action<object, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>>>)Optimizers_ItemsMoved, sender, e);
266        return;
267      }
268
269      var optimizerList = (OptimizerList)sender;
270      IEnumerable<TreeNodeCollection> parentNodes;
271      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
272      else {
273        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
274        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
275      }
276
277      foreach (TreeNodeCollection parentNode in parentNodes) {
278        var backup = parentNode.OfType<TreeNode>().ToList();
279        foreach (var indexedItem in e.Items) {
280          var node = backup.Where(n => n.Tag == indexedItem.Value).First();
281          node.Remove();
282          parentNode.Insert(indexedItem.Index, node);
283        }
284      }
285    }
286    private void Optimizers_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>> e) {
287      if (InvokeRequired) {
288        Invoke((Action<object, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>>>)Optimizers_ItemsRemoved, sender, e);
289        return;
290      }
291
292      var optimizerList = (OptimizerList)sender;
293      IEnumerable<TreeNodeCollection> parentNodes;
294      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
295      else {
296        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
297        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
298      }
299
300      foreach (TreeNodeCollection parentNode in parentNodes) {
301        foreach (var childOptimizer in e.Items) {
302          TreeNode childNode = parentNode[childOptimizer.Index];
303          DisposeTreeNode(childNode);
304          childNode.Remove();
305        }
306      }
307      RebuildImageList();
308      UpdateDetailsViewHost();
309    }
310    private void Optimizers_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>> e) {
311      if (InvokeRequired) {
312        Invoke((Action<object, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>>>)Optimizers_ItemsReplaced, sender, e);
313        return;
314      }
315
316      var optimizerList = (OptimizerList)sender;
317      IEnumerable<TreeNodeCollection> parentNodes;
318      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
319      else {
320        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
321        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
322      }
323
324      foreach (TreeNodeCollection parentNode in parentNodes) {
325        foreach (var childOptimizer in e.OldItems) {
326          TreeNode childNode = parentNode.Cast<TreeNode>().Where(n => n.Tag == childOptimizer.Value && n.Index == childOptimizer.Index).First();
327          DisposeTreeNode(childNode);
328          childNode.Remove();
329        }
330        foreach (var childOptimizer in e.Items) {
331          TreeNode childNode = CreateTreeNode(childOptimizer.Value);
332          UpdateChildTreeNodes(childNode.Nodes, childOptimizer.Value);
333          parentNode.Insert(childOptimizer.Index, childNode);
334        }
335      }
336      RebuildImageList();
337      UpdateDetailsViewHost();
338    }
339    private void Optimizers_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>> e) {
340      if (InvokeRequired) {
341        Invoke((Action<object, CollectionItemsChangedEventArgs<IndexedItem<IOptimizer>>>)Optimizers_CollectionReset, sender, e);
342        return;
343      }
344
345      var optimizerList = (OptimizerList)sender;
346      IEnumerable<TreeNodeCollection> parentNodes;
347      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
348      else {
349        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
350        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
351      }
352
353      foreach (TreeNodeCollection parentNode in parentNodes) {
354        foreach (var childOptimizer in e.OldItems) {
355          TreeNode childNode = parentNode.Cast<TreeNode>().Where(n => n.Tag == childOptimizer.Value && n.Index == childOptimizer.Index).First();
356          DisposeTreeNode(childNode);
357          childNode.Remove();
358        }
359        foreach (var childOptimizer in e.Items) {
360          TreeNode childNode = CreateTreeNode(childOptimizer.Value);
361          UpdateChildTreeNodes(childNode.Nodes, childOptimizer.Value);
362          parentNode.Insert(childOptimizer.Index, childNode);
363        }
364      }
365      RebuildImageList();
366      UpdateDetailsViewHost();
367    }
368
369    private void namedItem_ToStringChanged(object sender, EventArgs e) {
370      if (InvokeRequired) {
371        Invoke((Action<object, EventArgs>)namedItem_ToStringChanged, sender, e);
372        return;
373      }
374      var namedItem = (INamedItem)sender;
375      foreach (TreeNode node in treeNodeTagMapping[namedItem]) {
376        node.Text = namedItem.ToString();
377        var batchRun = namedItem as BatchRun;
378        if (batchRun != null)
379          node.Text += string.Format(" {0}/{1}", batchRun.RepetitionsCounter, batchRun.Repetitions);
380      }
381    }
382
383    private void namedItem_ItemImageChanged(object sender, EventArgs e) {
384      if (InvokeRequired) {
385        Invoke((Action<object, EventArgs>)namedItem_ItemImageChanged, sender, e);
386        return;
387      }
388      INamedItem namedItem = (INamedItem)sender;
389      foreach (TreeNode node in treeNodeTagMapping[namedItem]) {
390        treeView.ImageList.Images[node.ImageIndex] = namedItem.ItemImage;
391        node.ImageIndex = node.ImageIndex;
392      }
393      SetEnabledStateOfControls();
394    }
395    #endregion
396
397    protected override void PropagateStateChanges(Control control, Type type, System.Reflection.PropertyInfo propertyInfo) {
398      return;
399    }
400
401    protected override void SetEnabledStateOfControls() {
402      base.SetEnabledStateOfControls();
403      IOptimizer optimizer = null;
404      IAlgorithm algorithm = null;
405      BatchRun batchRun = null;
406      Experiment experiment = null;
407
408      IOptimizer parentOptimizer = null;
409      Experiment parentExperiment = null;
410
411      if (treeView.SelectedNode != null) {
412        optimizer = treeView.SelectedNode.Tag as IOptimizer;
413        algorithm = optimizer as IAlgorithm;
414        batchRun = optimizer as BatchRun;
415        experiment = optimizer as Experiment;
416
417        if (treeView.SelectedNode.Parent != null) parentOptimizer = treeView.SelectedNode.Parent.Tag as IOptimizer;
418        else parentOptimizer = Content;
419
420        parentExperiment = parentOptimizer as Experiment;
421      }
422
423      treeView.Enabled = Content != null;
424      if (parentOptimizer != null) {
425        detailsViewHost.ReadOnly = parentOptimizer.ExecutionState == ExecutionState.Started;
426        detailsViewHost.Locked = parentOptimizer.ExecutionState == ExecutionState.Started;
427      }
428
429      addButton.Enabled = Content != null && !Locked && !ReadOnly &&
430        (treeView.SelectedNode == null || experiment != null || batchRun != null || algorithm != null);
431      moveUpButton.Enabled = Content != null && !Locked && !ReadOnly &&
432        treeView.SelectedNode != null && treeView.SelectedNode.PrevNode != null && parentExperiment != null;
433      moveDownButton.Enabled = Content != null && !Locked && !ReadOnly &&
434        treeView.SelectedNode != null && treeView.SelectedNode.NextNode != null && parentExperiment != null;
435      removeButton.Enabled = Content != null && !Locked && !ReadOnly && optimizer != null;
436    }
437
438    private void UpdateOptimizerTreeView() {
439      treeView.Nodes.Clear();
440      UpdateChildTreeNodes(treeView.Nodes, Content);
441      RebuildImageList();
442    }
443
444    private void UpdateChildTreeNodes(TreeNodeCollection collection, IOptimizer optimizer) {
445      var batchRun = optimizer as BatchRun;
446      var experiment = optimizer as Experiment;
447
448      if (batchRun != null && batchRun.Optimizer != null) UpdateChildTreeNodes(collection, new List<IOptimizer>() { batchRun.Optimizer });
449      else if (experiment != null) UpdateChildTreeNodes(collection, experiment.Optimizers);
450    }
451    private void UpdateChildTreeNodes(TreeNodeCollection collection, IEnumerable<IOptimizer> optimizers) {
452      foreach (IOptimizer optimizer in optimizers) {
453        var node = CreateTreeNode(optimizer);
454        collection.Add(node);
455        UpdateChildTreeNodes(node.Nodes, optimizer);
456      }
457    }
458
459
460    #region drag & drop
461    private void optimizerTreeView_ItemDrag(object sender, ItemDragEventArgs e) {
462      if (Locked) return;
463
464      TreeNode selectedNode = (TreeNode)e.Item;
465      var item = (IItem)selectedNode.Tag;
466      if (item == null) return;
467
468      DataObject data = new DataObject();
469      data.SetData(HeuristicLab.Common.Constants.DragDropDataFormat, item);
470      validDragOperation = true;
471
472      if (ReadOnly || !(item is IOptimizer)) {
473        DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link);
474      } else {
475        DragDropEffects result = DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link | DragDropEffects.Move);
476        if ((result & DragDropEffects.Move) == DragDropEffects.Move) {
477          var optimizer = (IOptimizer)item;
478          if (selectedNode.Parent == null) Content.Optimizers.Remove(optimizer);
479          else {
480            var parentOptimizer = (IOptimizer)selectedNode.Parent.Tag;
481            var parentBatchRun = parentOptimizer as BatchRun;
482            var parentExperiment = parentOptimizer as Experiment;
483            if (parentBatchRun != null) parentBatchRun.Optimizer = null;
484            else if (parentExperiment != null) parentExperiment.Optimizers.Remove(optimizer);
485            else throw new NotSupportedException("Handling for specific type not implemented" + parentOptimizer.GetType());
486          }
487        }
488      }
489    }
490
491    private bool validDragOperation = false;
492    private void optimizerTreeView_DragEnter(object sender, DragEventArgs e) {
493      validDragOperation = false;
494      if (!ReadOnly) {
495        var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
496        if (data is IOptimizer) validDragOperation = true;
497        else if (data is IProblem) validDragOperation = true;
498        else if (data is IEnumerable) {
499          IEnumerable items = (IEnumerable)data;
500          validDragOperation = true;
501          foreach (object item in items)
502            validDragOperation = validDragOperation && (item is IOptimizer);
503        }
504      }
505    }
506    private void optimizerTreeView_DragOver(object sender, DragEventArgs e) {
507      e.Effect = DragDropEffects.None;
508      if (!validDragOperation) return;
509      Point coordinates = treeView.PointToClient(new Point(e.X, e.Y));
510      TreeNode node = treeView.GetNodeAt(coordinates);
511      Experiment experiment = null;
512      BatchRun batchRun = null;
513      Algorithm algorithm = null;
514
515      if (node == null) experiment = Content;
516      else {
517        experiment = node.Tag as Experiment;
518        batchRun = node.Tag as BatchRun;
519        algorithm = node.Tag as Algorithm;
520      }
521
522      if (batchRun == null && experiment == null && algorithm == null) return;
523
524      var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
525
526      if (algorithm != null) {
527        var problem = data as IProblem;
528        if (problem == null) return;
529        if (!algorithm.ProblemType.IsAssignableFrom(problem.GetType())) return;
530      } else if (batchRun != null) {
531        var optimizer = data as IOptimizer;
532        if (optimizer == null) return;
533        if (batchRun == optimizer) return;
534        if (optimizer.NestedOptimizers.Contains(batchRun)) return;
535      } //do not allow recursive nesting of contents
536      else if (experiment != null) {
537        var optimizer = data as IOptimizer;
538        IEnumerable<IOptimizer> optimizers = null;
539        var enumerable = data as IEnumerable;
540        if (enumerable != null) optimizers = enumerable.Cast<IOptimizer>();
541        if (experiment == optimizer) return;
542        if (optimizer != null && optimizer.NestedOptimizers.Contains(experiment)) return;
543        if (optimizers != null && optimizers.Any(x => x.NestedOptimizers.Contains(experiment))) return;
544      }
545
546      if ((e.KeyState & 32) == 32 && e.AllowedEffect.HasFlag(DragDropEffects.Link)) e.Effect = DragDropEffects.Link;  // ALT key
547      else if ((e.KeyState & 4) == 4 && e.AllowedEffect.HasFlag(DragDropEffects.Move)) e.Effect = DragDropEffects.Move;  // SHIFT key
548      else if (e.AllowedEffect.HasFlag(DragDropEffects.Copy)) e.Effect = DragDropEffects.Copy;
549      else if (e.AllowedEffect.HasFlag(DragDropEffects.Move)) e.Effect = DragDropEffects.Move;
550      else if (e.AllowedEffect.HasFlag(DragDropEffects.Link)) e.Effect = DragDropEffects.Link;
551    }
552
553    private void optimizerTreeView_DragDrop(object sender, DragEventArgs e) {
554      Point coordinates = treeView.PointToClient(new Point(e.X, e.Y));
555      TreeNode node = treeView.GetNodeAt(coordinates);
556      Algorithm algorithm = null;
557      BatchRun batchRun = null;
558      Experiment experiment = null;
559
560      if (node == null) experiment = Content;
561      else {
562        algorithm = node.Tag as Algorithm;
563        batchRun = node.Tag as BatchRun;
564        experiment = node.Tag as Experiment;
565      }
566
567      var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
568      if (data is IProblem) {
569        var problem = (IProblem)data;
570        if (e.Effect.HasFlag(DragDropEffects.Copy)) problem = (IProblem)problem.Clone();
571        algorithm.Problem = problem;
572      } else if (data is IOptimizer) {
573        IOptimizer optimizer = (IOptimizer)data;
574        if (e.Effect.HasFlag(DragDropEffects.Copy)) optimizer = (IOptimizer)optimizer.Clone();
575        if (batchRun != null) batchRun.Optimizer = optimizer;
576        else if (experiment != null) experiment.Optimizers.Add(optimizer);
577        else throw new NotSupportedException("Handling for specific type not implemented" + node.Tag.GetType());
578      } else if (data is IEnumerable) {
579        IEnumerable<IOptimizer> optimizers = ((IEnumerable)data).Cast<IOptimizer>();
580        if (e.Effect.HasFlag(DragDropEffects.Copy)) {
581          Cloner cloner = new Cloner();
582          optimizers = optimizers.Select(o => cloner.Clone(o));
583        }
584        if (experiment != null) experiment.Optimizers.AddRange(optimizers);
585        else throw new NotSupportedException("Handling for specific type not implemented" + node.Tag.GetType());
586      }
587    }
588    #endregion
589
590    #region control events
591    private void treeView_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e) {
592      if (rightClickOccured) return;
593      if (e.X < e.Node.Bounds.Left - treeView.ImageList.Images[e.Node.ImageIndex].Width || e.X > e.Node.Bounds.Right) return;
594      e.Node.Toggle();
595      IContent optimizer = (IContent)e.Node.Tag;
596      MainFormManager.MainForm.ShowContent(optimizer);
597    }
598    private void treeview_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) {
599      if (e.X < e.Node.Bounds.Left - treeView.ImageList.Images[e.Node.ImageIndex].Width || e.X > e.Node.Bounds.Right) return;
600      treeView.SelectedNode = e.Node;
601      detailsViewHost.Content = (IContent)e.Node.Tag;
602      SetEnabledStateOfControls();
603    }
604    private void treeView_MouseDown(object sender, MouseEventArgs e) {
605      // enables deselection of treeNodes
606      if (e.Button != MouseButtons.Right) rightClickOccured = false;
607      if (treeView.SelectedNode == null) return;
608      Point coordinates = new Point(e.X, e.Y);
609      TreeNode node = treeView.GetNodeAt(coordinates);
610      if (node == null || coordinates.X < node.Bounds.Left - treeView.ImageList.Images[node.ImageIndex].Width || coordinates.X > node.Bounds.Right) {
611        treeView.SelectedNode = null;
612        detailsViewHost.Content = null;
613        SetEnabledStateOfControls();
614      }
615    }
616
617
618    private void treeView_KeyDown(object sender, KeyEventArgs e) {
619      if (Locked || ReadOnly) return;
620      if (treeView.SelectedNode == null) return;
621      if (!(treeView.SelectedNode.Tag is INamedItem)) return;
622
623      var treeNode = treeView.SelectedNode;
624      var namedItem = (INamedItem)treeNode.Tag;
625      var optimizer = namedItem as IOptimizer;
626
627      if (e.KeyCode == Keys.Delete && optimizer != null) {
628        if (treeNode.Parent == null)
629          Content.Optimizers.Remove(optimizer);
630        else {
631          var batchRun = treeNode.Parent.Tag as BatchRun;
632          var experiment = treeNode.Parent.Tag as Experiment;
633          if (batchRun != null) batchRun.Optimizer = null;
634          else if (experiment != null) experiment.Optimizers.Remove(optimizer);
635          else throw new NotSupportedException("Handling for specific type not implemented" + treeView.SelectedNode.Tag.GetType());
636        }
637        SetEnabledStateOfControls();
638        UpdateDetailsViewHost();
639        RebuildImageList();
640      }
641    }
642
643
644    private void treeView_AfterSelect(object sender, TreeViewEventArgs e) {
645      if (e.Action == TreeViewAction.ByKeyboard) {
646        UpdateDetailsViewHost();
647        //NOTE: necessary because algorithm view steals the focus
648        treeView.Focus();
649      }
650    }
651
652    private bool rightClickOccured = true;
653    private TreeNode toolStripMenuNode = null;
654    private void treeView_RightClick(object sender, EventArgs e) {
655      rightClickOccured = true;
656      Point coordinates = treeView.PointToClient(Cursor.Position);
657      toolStripMenuNode = treeView.GetNodeAt(coordinates);
658
659      if (toolStripMenuNode != null && coordinates.X >= toolStripMenuNode.Bounds.Left && coordinates.X <= toolStripMenuNode.Bounds.Right) {
660        treeView.SelectedNode = toolStripMenuNode;
661        detailsViewHost.Content = (IContent)toolStripMenuNode.Tag;
662        SetEnabledStateOfControls();
663
664        ExpandToolStripMenuItem.Enabled = ExpandToolStripMenuItem.Visible = !toolStripMenuNode.IsExpanded && toolStripMenuNode.Nodes.Count > 0;
665        CollapseToolStripMenuItem.Enabled = CollapseToolStripMenuItem.Visible = toolStripMenuNode.IsExpanded;
666      } else {
667        ExpandToolStripMenuItem.Enabled = ExpandToolStripMenuItem.Visible = false;
668        CollapseToolStripMenuItem.Enabled = CollapseToolStripMenuItem.Visible = false;
669      }
670      ExpandAllToolStripMenuItem.Enabled = ExpandAllToolStripMenuItem.Visible = !treeView.Nodes.OfType<TreeNode>().All(x => TreeNodeIsFullyExpanded(x));
671      CollapseAllToolStripMenuItem.Enabled = CollapseAllToolStripMenuItem.Visible = treeView.Nodes.OfType<TreeNode>().Any(x => x.IsExpanded);
672      if (contextMenuStrip.Items.Cast<ToolStripMenuItem>().Any(item => item.Enabled))
673        contextMenuStrip.Show(Cursor.Position);
674    }
675
676    private void ExpandToolStripMenuItem_Click(object sender, EventArgs e) {
677      if (toolStripMenuNode != null) toolStripMenuNode.ExpandAll();
678    }
679    private void ExpandAllToolStripMenuItem_Click(object sender, EventArgs e) {
680      treeView.ExpandAll();
681    }
682    private void CollapseToolStripMenuItem_Click(object sender, EventArgs e) {
683      if (toolStripMenuNode != null) toolStripMenuNode.Collapse();
684    }
685    private void CollapseAllToolStripMenuItem_Click(object sender, EventArgs e) {
686      treeView.CollapseAll();
687    }
688
689    private void addButton_Click(object sender, System.EventArgs e) {
690      if (typeSelectorDialog == null) typeSelectorDialog = new TypeSelectorDialog();
691
692      IAlgorithm algorithm = null;
693      if (treeView.SelectedNode != null && (treeView.SelectedNode.Tag is IAlgorithm))
694        algorithm = (IAlgorithm)treeView.SelectedNode.Tag;
695
696      if (algorithm == null) {
697        typeSelectorDialog.Caption = "Select Optimizer";
698        typeSelectorDialog.TypeSelector.Caption = "Available Optimizers";
699        typeSelectorDialog.TypeSelector.Configure(typeof(IOptimizer), false, true);
700      } else {
701        typeSelectorDialog.Caption = "Select Problem";
702        typeSelectorDialog.TypeSelector.Caption = "Available Problems";
703        typeSelectorDialog.TypeSelector.Configure(algorithm.ProblemType, false, true);
704      }
705
706      if (typeSelectorDialog.ShowDialog(this) == DialogResult.OK) {
707        try {
708          if (algorithm == null) {
709            IOptimizer optimizer = (IOptimizer)typeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
710            if (treeView.SelectedNode == null) Content.Optimizers.Add(optimizer);
711            else {
712              var batchRun = treeView.SelectedNode.Tag as BatchRun;
713              var experiment = treeView.SelectedNode.Tag as Experiment;
714              if (batchRun != null) batchRun.Optimizer = optimizer;
715              else if (experiment != null) experiment.Optimizers.Add(optimizer);
716              else throw new NotSupportedException("Handling for specific type not implemented" + treeView.SelectedNode.Tag.GetType());
717            }
718          } else {
719            IProblem problem = (IProblem)typeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
720            algorithm.Problem = problem;
721          }
722        }
723        catch (Exception ex) {
724          ErrorHandling.ShowErrorDialog(this, ex);
725        }
726      }
727    }
728
729    private void moveUpButton_Click(object sender, EventArgs e) {
730      var optimizer = (IOptimizer)treeView.SelectedNode.Tag;
731      Experiment experiment = null;
732      if (treeView.SelectedNode.Parent == null) experiment = Content;
733      else experiment = (Experiment)treeView.SelectedNode.Parent.Tag;
734
735      var selectedNode = treeView.SelectedNode;
736      int index = treeView.SelectedNode.Index;
737      experiment.Optimizers.Reverse(index - 1, 2);
738      treeView.SelectedNode = selectedNode;
739      SetEnabledStateOfControls();
740    }
741    private void moveDownButton_Click(object sender, EventArgs e) {
742      var optimizer = (IOptimizer)treeView.SelectedNode.Tag;
743      Experiment experiment = null;
744      if (treeView.SelectedNode.Parent == null) experiment = Content;
745      else experiment = (Experiment)treeView.SelectedNode.Parent.Tag;
746
747      var selectedNode = treeView.SelectedNode;
748      int index = treeView.SelectedNode.Index;
749      experiment.Optimizers.Reverse(index, 2);
750      treeView.SelectedNode = selectedNode;
751      SetEnabledStateOfControls();
752    }
753
754    private void removeButton_Click(object sender, EventArgs e) {
755      var treeNode = treeView.SelectedNode;
756      var optimizer = treeNode.Tag as IOptimizer;
757
758      if (treeNode.Parent == null)
759        Content.Optimizers.Remove(optimizer);
760      else {
761        var batchRun = treeNode.Parent.Tag as BatchRun;
762        var experiment = treeNode.Parent.Tag as Experiment;
763        if (batchRun != null) batchRun.Optimizer = null;
764        else if (experiment != null) experiment.Optimizers.Remove(optimizer);
765        else throw new NotSupportedException("Handling for specific type not implemented" + treeView.SelectedNode.Tag.GetType());
766      }
767      SetEnabledStateOfControls();
768      UpdateDetailsViewHost();
769      RebuildImageList();
770    }
771
772    private void showDetailsCheckBox_CheckedChanged(object sender, System.EventArgs e) {
773      if (showDetailsCheckBox.Checked) {
774        splitContainer.Panel2Collapsed = false;
775        detailsGroupBox.Enabled = treeView.SelectedNode != null;
776        detailsViewHost.Content = treeView.SelectedNode != null ? (IContent)treeView.SelectedNode.Tag : null;
777      } else {
778        splitContainer.Panel2Collapsed = true;
779        detailsViewHost.Content = null;
780      }
781    }
782    #endregion
783
784    #region helpers
785    private void UpdateDetailsViewHost() {
786      if (treeView.SelectedNode != null)
787        detailsViewHost.Content = (IContent)treeView.SelectedNode.Tag;
788      else
789        detailsViewHost.Content = null;
790    }
791
792    private TreeNode CreateTreeNode(IOptimizer optimizer) {
793      TreeNode node = new TreeNode(optimizer.ToString());
794      node.Tag = optimizer;
795
796      var algorithm = optimizer as IAlgorithm;
797      if (algorithm != null) {
798        foreach (TreeNode childNode in CreateAlgorithmChildNodes(algorithm))
799          node.Nodes.Add(childNode);
800      }
801      var batchRun = optimizer as BatchRun;
802      if (batchRun != null) {
803        node.Text += string.Format(" {0}/{1}", batchRun.RepetitionsCounter, batchRun.Repetitions);
804      }
805
806      List<TreeNode> nodes;
807      if (!treeNodeTagMapping.TryGetValue(optimizer, out nodes)) {
808        nodes = new List<TreeNode>();
809        treeNodeTagMapping.Add(optimizer, nodes);
810        RegisterNamedItemEvents(optimizer);
811      }
812      nodes.Add(node);
813
814      foreach (TreeNode childNode in node.Nodes) {
815        INamedItem namedItem = childNode.Tag as INamedItem;
816        if (namedItem != null) {
817          if (!treeNodeTagMapping.TryGetValue(namedItem, out nodes)) {
818            nodes = new List<TreeNode>();
819            treeNodeTagMapping.Add(namedItem, nodes);
820            RegisterNamedItemEvents(namedItem);
821          }
822          nodes.Add(childNode);
823        }
824      }
825      return node;
826    }
827
828    private IEnumerable<TreeNode> CreateAlgorithmChildNodes(IAlgorithm algorithm) {
829      TreeNode problemNode;
830      if (algorithm.Problem != null) {
831        problemNode = new TreeNode(algorithm.Problem.Name);
832        problemNode.Tag = algorithm.Problem;
833      } else {
834        problemNode = new TreeNode("No Problem");
835        problemNode.Tag = null;
836      }
837      TreeNode parametersNode = new TreeNode("Parameters");
838      parametersNode.Tag = algorithm.Parameters;
839      TreeNode resultsNode = new TreeNode("Results");
840      resultsNode.Tag = algorithm.Results;
841
842      yield return problemNode;
843      yield return parametersNode;
844      yield return resultsNode;
845    }
846
847    private void DisposeTreeNode(TreeNode node) {
848      var namedItem = node.Tag as INamedItem;
849      if (namedItem == null) return;
850
851      List<TreeNode> nodes;
852      if (!treeNodeTagMapping.TryGetValue(namedItem, out nodes))
853        throw new ArgumentException();
854      nodes.Remove(node);
855      if (nodes.Count == 0) {
856        treeNodeTagMapping.Remove(namedItem);
857        DeregisterNamedItemEvents(namedItem);
858      }
859    }
860
861    private IEnumerable<TreeNode> IterateTreeNodes(TreeNode node = null) {
862      TreeNodeCollection nodes;
863      if (node == null)
864        nodes = treeView.Nodes;
865      else {
866        nodes = node.Nodes;
867        yield return node;
868      }
869
870      foreach (var childNode in nodes.OfType<TreeNode>())
871        foreach (var n in IterateTreeNodes(childNode))
872          yield return n;
873    }
874
875    private bool TreeNodeIsFullyExpanded(TreeNode node) {
876      return (node.Nodes.Count == 0) || (node.IsExpanded && node.Nodes.OfType<TreeNode>().All(x => TreeNodeIsFullyExpanded(x)));
877    }
878
879    private void RebuildImageList() {
880      if (InvokeRequired) {
881        Invoke((Action)RebuildImageList);
882        return;
883      }
884
885      treeView.BeginUpdate();
886
887      treeView.ImageList.Images.Clear();
888      var topLevelNodes = treeView.Nodes.OfType<TreeNode>().ToArray();
889      var nodes = IterateTreeNodes().ToList();
890      var selectedNode = treeView.SelectedNode;
891      treeView.Nodes.Clear();
892
893      foreach (TreeNode treeNode in nodes) {
894        var item = (IItem)treeNode.Tag;
895        treeView.ImageList.Images.Add(item == null ? HeuristicLab.Common.Resources.VSImageLibrary.Nothing : item.ItemImage);
896        treeNode.ImageIndex = treeView.ImageList.Images.Count - 1;
897        treeNode.SelectedImageIndex = treeNode.ImageIndex;
898      }
899      treeView.Nodes.AddRange(topLevelNodes);
900      treeView.SelectedNode = selectedNode;
901      treeView.EndUpdate();
902    }
903    #endregion
904
905
906    public sealed class CustomTreeView : System.Windows.Forms.TreeView {
907      protected override void WndProc(ref System.Windows.Forms.Message m) {
908        const int WM_RBUTTONDOWN = 0x204;
909        if (m.Msg == WM_RBUTTONDOWN) {
910          //Raise your custom event right click event to prevent node highlighting
911          OnRightClick();
912          return;
913        }
914        base.WndProc(ref m);
915      }
916
917      public event EventHandler RightClick;
918      private void OnRightClick() {
919        var handler = RightClick;
920        if (handler != null) RightClick(this, EventArgs.Empty);
921      }
922    }
923  }
924}
Note: See TracBrowser for help on using the repository browser.