Free cookie consent management tool by TermsFeed Policy Generator

source: branches/NewItemDialog/HeuristicLab.Optimizer/3.3/NewItemDialog.cs @ 12239

Last change on this file since 12239 was 12239, checked in by pfleck, 8 years ago

#2025

  • Separated item- and plugin-description.
  • Clear and collapse when showing the dialog instead of showing the last selected item.
  • Added tooltips.
File size: 15.7 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.Core;
29using HeuristicLab.PluginInfrastructure;
30
31namespace HeuristicLab.Optimizer {
32  internal partial class NewItemDialog : Form {
33    private bool isInitialized;
34
35    private List<TreeNode> treeNodes;
36    private string currentSearchString;
37
38    private Type selectedType;
39    public Type SelectedType {
40      get { return selectedType; }
41      private set {
42        if (value != selectedType) {
43          selectedType = value;
44          OnSelectedTypeChanged();
45        }
46      }
47    }
48
49    private IItem item;
50    public IItem Item {
51      get { return item; }
52    }
53
54    public NewItemDialog() {
55      InitializeComponent();
56      treeNodes = new List<TreeNode>();
57      currentSearchString = string.Empty;
58      item = null;
59      SelectedTypeChanged += this_SelectedTypeChanged;
60    }
61
62    private void NewItemDialog_Load(object sender, EventArgs e) {
63      if (isInitialized) return;
64
65      var categories =
66        from type in ApplicationManager.Manager.GetTypes(typeof(IItem))
67        let category = CreatableAttribute.GetCategory(type)
68        let name = ItemAttribute.GetName(type)
69        let version = ItemAttribute.GetVersion(type)
70        where CreatableAttribute.IsCreatable(type)
71        orderby category, name, version ascending
72        group type by category into categoryGroup
73        select categoryGroup;
74
75      var rootNode = CreateCategoryTree(categories);
76      CreateItemNodes(rootNode, categories);
77
78      foreach (TreeNode topNode in rootNode.Nodes)
79        treeNodes.Add(topNode);
80      foreach (var node in treeNodes)
81        typesTreeView.Nodes.Add((TreeNode)node.Clone());
82
83      typesTreeView.TreeViewNodeSorter = new ItemTreeNodeComparer();
84      typesTreeView.Sort();
85
86      isInitialized = true;
87    }
88
89    private TreeNode CreateCategoryTree(IEnumerable<IGrouping<string, Type>> categories) {
90      imageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.Class);      // default icon
91      imageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.Namespace);  // plugins
92
93      var rootNode = new TreeNode();
94
95      foreach (var category in categories) {
96        var fullName = category.Key;
97        var tokens = fullName.Split('#');
98        var name = tokens.Last();
99        var parents = tokens.Take(tokens.Length - 1);
100
101        var categoryNode = new TreeNode(name, 1, 1) {
102          Name = fullName,
103          Tag = fullName
104        };
105
106        var parentNode = FindOrCreateParentNode(rootNode, parents);
107        if (parentNode != null)
108          parentNode.Nodes.Add(categoryNode);
109        else
110          rootNode.Nodes.Add(categoryNode);
111      }
112
113      return rootNode;
114    }
115    private TreeNode FindOrCreateParentNode(TreeNode node, IEnumerable<string> parentCategories) {
116      TreeNode parentNode = null;
117      string fullName = null;
118      foreach (string parentCategory in parentCategories) {
119        fullName = fullName == null ? parentCategory : fullName + "#" + parentCategory;
120        parentNode = node.Nodes.Find(fullName, searchAllChildren: false).SingleOrDefault();
121        if (parentNode == null) {
122          parentNode = new TreeNode(parentCategory, 1, 1) {
123            Name = fullName,
124            Tag = fullName
125          };
126          node.Nodes.Add(parentNode);
127        }
128        node = parentNode;
129      }
130      return parentNode;
131    }
132    private void CreateItemNodes(TreeNode node, IEnumerable<IGrouping<string, Type>> categories) {
133      foreach (var category in categories) {
134        var categoryNode = node.Nodes.Find(category.Key, searchAllChildren: true).Single();
135        foreach (var creatable in category) {
136          var itemNode = CreateItemNode(creatable);
137          itemNode.Name = itemNode.Name + ":" + category.Key;
138          categoryNode.Nodes.Add(itemNode);
139        }
140      }
141    }
142    private TreeNode CreateItemNode(Type creatable) {
143      string name = ItemAttribute.GetName(creatable);
144
145      var itemNode = new TreeNode(name) {
146        ImageIndex = 0,
147        Tag = creatable,
148        Name = name
149      };
150
151      var image = ItemAttribute.GetImage(creatable);
152      if (image != null) {
153        imageList.Images.Add(image);
154        itemNode.ImageIndex = imageList.Images.Count - 1;
155      }
156      itemNode.SelectedImageIndex = itemNode.ImageIndex;
157
158      return itemNode;
159    }
160
161    private void NewItemDialog_Shown(object sender, EventArgs e) {
162      searchTextBox.Text = string.Empty;
163      searchTextBox.Focus();
164      SelectedType = null;
165      typesTreeView.SelectedNode = null;
166      typesTreeView.CollapseAll();
167      UpdateDescription();
168    }
169
170    public virtual void Filter(string searchString) {
171      if (InvokeRequired) {
172        Invoke(new Action<string>(Filter), searchString);
173      } else {
174        searchString = searchString.ToLower();
175
176        if (!searchString.Contains(currentSearchString)) {
177          typesTreeView.BeginUpdate();
178          // expand search -> restore all tree nodes
179          var selectedNode = typesTreeView.SelectedNode;
180          typesTreeView.Nodes.Clear();
181          foreach (TreeNode node in treeNodes)
182            typesTreeView.Nodes.Add((TreeNode)node.Clone());
183          RestoreSelectedNode(selectedNode);
184          typesTreeView.EndUpdate();
185        }
186
187        // remove nodes
188        typesTreeView.BeginUpdate();
189        var searchTokens = searchString.Split(' ');
190
191        int i = 0;
192        while (i < typesTreeView.Nodes.Count) {
193          var categoryNode = typesTreeView.Nodes[i];
194          bool remove = FilterNode(categoryNode, searchTokens);
195          if (remove)
196            typesTreeView.Nodes.RemoveAt(i);
197          else i++;
198        }
199        typesTreeView.EndUpdate();
200        currentSearchString = searchString;
201
202        // select first item
203        var firstNode = FirstVisibleNode;
204        while (firstNode != null && !(firstNode.Tag is Type))
205          firstNode = firstNode.NextVisibleNode;
206        if (firstNode != null)
207          typesTreeView.SelectedNode = firstNode;
208
209        if (typesTreeView.Nodes.Count == 0) {
210          SelectedType = null;
211          typesTreeView.Enabled = false;
212        } else {
213          SetTreeNodeVisibility();
214          typesTreeView.Enabled = true;
215        }
216        UpdateDescription();
217      }
218    }
219
220    private bool FilterNode(TreeNode node, string[] searchTokens) {
221      if (node.Tag is string) { // Category node
222        int i = 0;
223        while (i < node.Nodes.Count) {
224          bool remove = FilterNode(node.Nodes[i], searchTokens);
225          if (remove)
226            node.Nodes.RemoveAt(i);
227          else i++;
228        }
229        return node.Nodes.Count == 0;
230      }
231      if (node.Tag is Type) { // Type node
232        var text = node.Text;
233        if (searchTokens.Any(searchToken => !text.ToLower().Contains(searchToken))) {
234          var typeTag = (Type)node.Tag;
235          if (typeTag.Equals(SelectedType)) {
236            SelectedType = null;
237            typesTreeView.SelectedNode = null;
238          }
239          return true;
240        }
241        return false;
242      }
243      return true;
244    }
245
246    protected virtual void UpdateDescription() {
247      itemDescriptionTextBox.Text = string.Empty;
248      pluginDescriptionTextBox.Text = string.Empty;
249      pluginTextBox.Text = string.Empty;
250      versionTextBox.Text = string.Empty;
251
252      if (typesTreeView.SelectedNode != null) {
253        string category = typesTreeView.SelectedNode.Tag as string;
254        if (category != null) {
255          itemDescriptionTextBox.Text = category;
256        }
257        Type type = typesTreeView.SelectedNode.Tag as Type;
258        if (type != null) {
259          string description = ItemAttribute.GetDescription(type);
260          var version = ItemAttribute.GetVersion(type);
261          var plugin = ApplicationManager.Manager.GetDeclaringPlugin(type);
262          if (description != null)
263            itemDescriptionTextBox.Text = description;
264          if (plugin != null) {
265            pluginTextBox.Text = plugin.Name;
266            pluginDescriptionTextBox.Text = plugin.Description;
267          }
268          if (version != null)
269            versionTextBox.Text = version.ToString();
270        }
271      } else if (typesTreeView.Nodes.Count == 0) {
272        itemDescriptionTextBox.Text = "No types found";
273      }
274    }
275
276    #region Events
277    public event EventHandler SelectedTypeChanged;
278    protected virtual void OnSelectedTypeChanged() {
279      if (SelectedTypeChanged != null)
280        SelectedTypeChanged(this, EventArgs.Empty);
281    }
282    #endregion
283
284    #region Control Events
285    protected virtual void searchTextBox_TextChanged(object sender, EventArgs e) {
286      Filter(searchTextBox.Text);
287    }
288
289    protected virtual void itemsTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
290      if (typesTreeView.SelectedNode == null) SelectedType = null;
291      else SelectedType = typesTreeView.SelectedNode.Tag as Type;
292      UpdateDescription();
293    }
294
295    protected virtual void itemsTreeView_VisibleChanged(object sender, EventArgs e) {
296      if (Visible) SetTreeNodeVisibility();
297    }
298    #endregion
299
300    #region Helpers
301    private void RestoreSelectedNode(TreeNode selectedNode) {
302      if (selectedNode != null) {
303        var node = typesTreeView.Nodes.Find(selectedNode.Name, searchAllChildren: true).SingleOrDefault();
304        typesTreeView.SelectedNode = node;
305        if (typesTreeView.SelectedNode == null) SelectedType = null;
306      }
307    }
308    private void SetTreeNodeVisibility() {
309      TreeNode selectedNode = typesTreeView.SelectedNode;
310      if (string.IsNullOrEmpty(currentSearchString) && (typesTreeView.Nodes.Count > 1)) {
311        typesTreeView.CollapseAll();
312        if (selectedNode != null) typesTreeView.SelectedNode = selectedNode;
313      } else {
314        typesTreeView.ExpandAll();
315      }
316      if (selectedNode != null) selectedNode.EnsureVisible();
317    }
318    #endregion
319
320    private void okButton_Click(object sender, EventArgs e) {
321      if (SelectedType != null) {
322        item = (IItem)Activator.CreateInstance(SelectedType);
323        DialogResult = DialogResult.OK;
324        Close();
325      }
326    }
327    private void itemTreeView_DoubleClick(object sender, EventArgs e) {
328      if (SelectedType != null) {
329        item = (IItem)Activator.CreateInstance(SelectedType);
330        DialogResult = DialogResult.OK;
331        Close();
332      }
333    }
334    private void this_SelectedTypeChanged(object sender, EventArgs e) {
335      okButton.Enabled = SelectedType != null;
336    }
337
338    private void expandAllButton_Click(object sender, EventArgs e) {
339      typesTreeView.ExpandAll();
340    }
341    private void collapseAllButton_Click(object sender, EventArgs e) {
342      typesTreeView.CollapseAll();
343    }
344
345    private TreeNode toolStripMenuNode = null;
346    private void typesTreeView_MouseDown(object sender, MouseEventArgs e) {
347      if (e.Button == MouseButtons.Right) {
348        Point coordinates = typesTreeView.PointToClient(Cursor.Position);
349        toolStripMenuNode = typesTreeView.GetNodeAt(coordinates);
350
351        if (toolStripMenuNode != null && coordinates.X >= toolStripMenuNode.Bounds.Left &&
352            coordinates.X <= toolStripMenuNode.Bounds.Right) {
353          typesTreeView.SelectedNode = toolStripMenuNode;
354
355          expandToolStripMenuItem.Enabled =
356            expandToolStripMenuItem.Visible = !toolStripMenuNode.IsExpanded && toolStripMenuNode.Nodes.Count > 0;
357          collapseToolStripMenuItem.Enabled = collapseToolStripMenuItem.Visible = toolStripMenuNode.IsExpanded;
358        } else {
359          expandToolStripMenuItem.Enabled = expandToolStripMenuItem.Visible = false;
360          collapseToolStripMenuItem.Enabled = collapseToolStripMenuItem.Visible = false;
361        }
362        expandAllToolStripMenuItem.Enabled =
363          expandAllToolStripMenuItem.Visible =
364            !typesTreeView.Nodes.OfType<TreeNode>().All(x => TreeNodeIsFullyExpanded(x));
365        collapseAllToolStripMenuItem.Enabled =
366          collapseAllToolStripMenuItem.Visible = typesTreeView.Nodes.OfType<TreeNode>().Any(x => x.IsExpanded);
367        if (contextMenuStrip.Items.Cast<ToolStripMenuItem>().Any(item => item.Enabled))
368          contextMenuStrip.Show(Cursor.Position);
369      }
370    }
371    private bool TreeNodeIsFullyExpanded(TreeNode node) {
372      return (node.Nodes.Count == 0) || (node.IsExpanded && node.Nodes.OfType<TreeNode>().All(x => TreeNodeIsFullyExpanded(x)));
373    }
374
375    private void expandToolStripMenuItem_Click(object sender, EventArgs e) {
376      if (toolStripMenuNode != null) toolStripMenuNode.ExpandAll();
377    }
378    private void expandAllToolStripMenuItem_Click(object sender, EventArgs e) {
379      typesTreeView.ExpandAll();
380    }
381    private void collapseToolStripMenuItem_Click(object sender, EventArgs e) {
382      if (toolStripMenuNode != null) toolStripMenuNode.Collapse();
383    }
384    private void collapseAllToolStripMenuItem_Click(object sender, EventArgs e) {
385      typesTreeView.CollapseAll();
386    }
387
388    private void clearSearchButton_Click(object sender, EventArgs e) {
389      searchTextBox.Text = string.Empty;
390      searchTextBox.Focus();
391    }
392
393    private void searchTextBox_KeyDown(object sender, KeyEventArgs e) {
394      if (typesTreeView.Nodes.Count == 0)
395        return;
396
397      if (e.KeyCode == Keys.Up || e.KeyCode == Keys.Down) {
398        var selectedNode = typesTreeView.SelectedNode;
399
400        if (selectedNode == null) { // nothing selected => select first or last
401          if (e.KeyCode == Keys.Down) typesTreeView.SelectedNode = FirstVisibleNode;
402          if (e.KeyCode == Keys.Up) typesTreeView.SelectedNode = LastVisibleNode;
403        } else {
404          if (e.KeyCode == Keys.Down)
405            typesTreeView.SelectedNode = selectedNode.NextVisibleNode ?? FirstVisibleNode; // select next or cycle to first
406          if (e.KeyCode == Keys.Up)
407            typesTreeView.SelectedNode = selectedNode.PrevVisibleNode ?? LastVisibleNode; // select prev or cycle to last
408        }
409        e.Handled = true;
410      }
411    }
412
413    private TreeNode FirstVisibleNode {
414      get {
415        return typesTreeView.Nodes.Count > 0 ? typesTreeView.Nodes[0] : null;
416      }
417    }
418    private TreeNode LastVisibleNode {
419      get {
420        var node = FirstVisibleNode;
421        while (node != null && node.NextVisibleNode != null) node = node.NextVisibleNode;
422        return node;
423      }
424    }
425
426    private class ItemTreeNodeComparer : IComparer {
427      public int Compare(object x, object y) {
428        var lhs = (TreeNode)x;
429        var rhs = (TreeNode)y;
430
431        if (lhs.Tag is string && rhs.Tag is string) {
432          return lhs.Name.CompareTo(rhs.Name);
433        } else if (lhs.Tag is string) {
434          return -1;
435        } else
436          return 1;
437      }
438    }
439  }
440}
Note: See TracBrowser for help on using the repository browser.