source: trunk/sources/HeuristicLab.Optimizer/3.3/NewItemDialog.cs @ 12393

Last change on this file since 12393 was 12393, checked in by pfleck, 7 years ago

#2025

  • Removed Expand/CollapseAll buttons.
  • Removed cycling of items.
File size: 15.6 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 readonly 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 priority = CreatableAttribute.GetPriority(type)
70        let version = ItemAttribute.GetVersion(type)
71        where CreatableAttribute.IsCreatable(type)
72        orderby category, priority, name, version ascending
73        group type by category into categoryGroup
74        select categoryGroup;
75
76      var rootNode = CreateCategoryTree(categories);
77      CreateItemNodes(rootNode, categories);
78
79      foreach (TreeNode topNode in rootNode.Nodes)
80        treeNodes.Add(topNode);
81      foreach (var node in treeNodes)
82        typesTreeView.Nodes.Add((TreeNode)node.Clone());
83
84      typesTreeView.TreeViewNodeSorter = new ItemTreeNodeComparer();
85      typesTreeView.Sort();
86
87      isInitialized = true;
88    }
89
90    private TreeNode CreateCategoryTree(IEnumerable<IGrouping<string, Type>> categories) {
91      imageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.Class);      // default icon
92      imageList.Images.Add(HeuristicLab.Common.Resources.VSImageLibrary.Namespace);  // plugins
93
94      var rootNode = new TreeNode();
95
96      foreach (var category in categories) {
97        var fullName = category.Key;
98        var tokens = fullName.Split('#');
99        var name = tokens.Last();
100        var parents = tokens.Take(tokens.Length - 1);
101
102        var categoryNode = new TreeNode(name, imageIndex: 1, selectedImageIndex: 1) {
103          Name = fullName,
104          Tag = fullName
105        };
106
107        var parentNode = FindOrCreateParentNode(rootNode, parents);
108        if (parentNode != null)
109          parentNode.Nodes.Add(categoryNode);
110        else
111          rootNode.Nodes.Add(categoryNode);
112      }
113
114      return rootNode;
115    }
116    private TreeNode FindOrCreateParentNode(TreeNode node, IEnumerable<string> parentCategories) {
117      TreeNode parentNode = null;
118      string fullName = null;
119      foreach (string parentCategory in parentCategories) {
120        fullName = fullName == null ? parentCategory : fullName + "#" + parentCategory;
121        parentNode = node.Nodes.Find(fullName, searchAllChildren: false).SingleOrDefault();
122        if (parentNode == null) {
123          parentNode = new TreeNode(parentCategory, imageIndex: 1, selectedImageIndex: 1) {
124            Name = fullName,
125            Tag = fullName
126          };
127          node.Nodes.Add(parentNode);
128        }
129        node = parentNode;
130      }
131      return parentNode;
132    }
133    private void CreateItemNodes(TreeNode node, IEnumerable<IGrouping<string, Type>> categories) {
134      foreach (var category in categories) {
135        var categoryNode = node.Nodes.Find(category.Key, searchAllChildren: true).Single();
136        foreach (var creatable in category) {
137          var itemNode = CreateItemNode(creatable);
138          itemNode.Name = itemNode.Name + ":" + category.Key;
139          categoryNode.Nodes.Add(itemNode);
140        }
141      }
142    }
143    private TreeNode CreateItemNode(Type creatable) {
144      string name = ItemAttribute.GetName(creatable);
145
146      var itemNode = new TreeNode(name) {
147        ImageIndex = 0,
148        Tag = creatable,
149        Name = name
150      };
151
152      var image = ItemAttribute.GetImage(creatable);
153      if (image != null) {
154        imageList.Images.Add(image);
155        itemNode.ImageIndex = imageList.Images.Count - 1;
156      }
157      itemNode.SelectedImageIndex = itemNode.ImageIndex;
158
159      return itemNode;
160    }
161
162    private void NewItemDialog_Shown(object sender, EventArgs e) {
163      searchTextBox.Text = string.Empty;
164      searchTextBox.Focus();
165      SelectedType = null;
166      typesTreeView.SelectedNode = null;
167      typesTreeView.CollapseAll();
168      UpdateDescription();
169    }
170
171    public virtual void Filter(string searchString) {
172      if (InvokeRequired) {
173        Invoke(new Action<string>(Filter), searchString);
174      } else {
175        searchString = searchString.ToLower();
176
177        if (!searchString.Contains(currentSearchString)) {
178          typesTreeView.BeginUpdate();
179          // expand search -> restore all tree nodes
180          var selectedNode = typesTreeView.SelectedNode;
181          typesTreeView.Nodes.Clear();
182          foreach (TreeNode node in treeNodes)
183            typesTreeView.Nodes.Add((TreeNode)node.Clone());
184          RestoreSelectedNode(selectedNode);
185          typesTreeView.EndUpdate();
186        }
187
188        // remove nodes
189        typesTreeView.BeginUpdate();
190        var searchTokens = searchString.Split(' ');
191
192        int i = 0;
193        while (i < typesTreeView.Nodes.Count) {
194          var categoryNode = typesTreeView.Nodes[i];
195          bool remove = FilterNode(categoryNode, searchTokens);
196          if (remove)
197            typesTreeView.Nodes.RemoveAt(i);
198          else i++;
199        }
200        typesTreeView.EndUpdate();
201        currentSearchString = searchString;
202
203        // select first item
204        var firstNode = FirstVisibleNode;
205        while (firstNode != null && !(firstNode.Tag is Type))
206          firstNode = firstNode.NextVisibleNode;
207        if (firstNode != null)
208          typesTreeView.SelectedNode = firstNode;
209
210        if (typesTreeView.Nodes.Count == 0) {
211          SelectedType = null;
212          typesTreeView.Enabled = false;
213        } else {
214          SetTreeNodeVisibility();
215          typesTreeView.Enabled = true;
216        }
217        UpdateDescription();
218      }
219    }
220
221    private bool FilterNode(TreeNode node, string[] searchTokens) {
222      if (node.Tag is string) { // Category node
223        int i = 0;
224        while (i < node.Nodes.Count) {
225          bool remove = FilterNode(node.Nodes[i], searchTokens);
226          if (remove)
227            node.Nodes.RemoveAt(i);
228          else i++;
229        }
230        return node.Nodes.Count == 0;
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 == SelectedType) {
236            SelectedType = null;
237            typesTreeView.SelectedNode = null;
238          }
239          return true;
240        }
241        return false;
242      }
243      throw new InvalidOperationException("Encountered neither a category nor a creatable node during tree traversal.");
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 TreeNode toolStripMenuNode = null;
339    private void typesTreeView_MouseDown(object sender, MouseEventArgs e) {
340      if (e.Button == MouseButtons.Right) {
341        Point coordinates = typesTreeView.PointToClient(Cursor.Position);
342        toolStripMenuNode = typesTreeView.GetNodeAt(coordinates);
343
344        if (toolStripMenuNode != null && coordinates.X >= toolStripMenuNode.Bounds.Left &&
345            coordinates.X <= toolStripMenuNode.Bounds.Right) {
346          typesTreeView.SelectedNode = toolStripMenuNode;
347
348          expandToolStripMenuItem.Enabled =
349            expandToolStripMenuItem.Visible = !toolStripMenuNode.IsExpanded && toolStripMenuNode.Nodes.Count > 0;
350          collapseToolStripMenuItem.Enabled = collapseToolStripMenuItem.Visible = toolStripMenuNode.IsExpanded;
351        } else {
352          expandToolStripMenuItem.Enabled = expandToolStripMenuItem.Visible = false;
353          collapseToolStripMenuItem.Enabled = collapseToolStripMenuItem.Visible = false;
354        }
355        expandAllToolStripMenuItem.Enabled =
356          expandAllToolStripMenuItem.Visible =
357            !typesTreeView.Nodes.OfType<TreeNode>().All(x => TreeNodeIsFullyExpanded(x));
358        collapseAllToolStripMenuItem.Enabled =
359          collapseAllToolStripMenuItem.Visible = typesTreeView.Nodes.OfType<TreeNode>().Any(x => x.IsExpanded);
360        if (contextMenuStrip.Items.Cast<ToolStripMenuItem>().Any(item => item.Enabled))
361          contextMenuStrip.Show(Cursor.Position);
362      }
363    }
364    private bool TreeNodeIsFullyExpanded(TreeNode node) {
365      return (node.Nodes.Count == 0) || (node.IsExpanded && node.Nodes.OfType<TreeNode>().All(x => TreeNodeIsFullyExpanded(x)));
366    }
367
368    private void expandToolStripMenuItem_Click(object sender, EventArgs e) {
369      if (toolStripMenuNode != null) toolStripMenuNode.ExpandAll();
370    }
371    private void expandAllToolStripMenuItem_Click(object sender, EventArgs e) {
372      typesTreeView.ExpandAll();
373    }
374    private void collapseToolStripMenuItem_Click(object sender, EventArgs e) {
375      if (toolStripMenuNode != null) toolStripMenuNode.Collapse();
376    }
377    private void collapseAllToolStripMenuItem_Click(object sender, EventArgs e) {
378      typesTreeView.CollapseAll();
379    }
380
381    private void clearSearchButton_Click(object sender, EventArgs e) {
382      searchTextBox.Text = string.Empty;
383      searchTextBox.Focus();
384    }
385
386    private void searchTextBox_KeyDown(object sender, KeyEventArgs e) {
387      if (typesTreeView.Nodes.Count == 0)
388        return;
389
390      if (e.KeyCode == Keys.Up || e.KeyCode == Keys.Down) {
391        var selectedNode = typesTreeView.SelectedNode;
392
393        if (selectedNode == null) { // nothing selected => select first
394          if (e.KeyCode == Keys.Down) typesTreeView.SelectedNode = FirstVisibleNode;
395        } else {
396          if (e.KeyCode == Keys.Down && selectedNode.NextVisibleNode != null)
397            typesTreeView.SelectedNode = selectedNode.NextVisibleNode;
398          if (e.KeyCode == Keys.Up && selectedNode.PrevVisibleNode != null)
399            typesTreeView.SelectedNode = selectedNode.PrevVisibleNode;
400        }
401        e.Handled = true;
402      }
403    }
404
405    private TreeNode FirstVisibleNode {
406      get {
407        return typesTreeView.Nodes.Count > 0 ? typesTreeView.Nodes[0] : null;
408      }
409    }
410    private TreeNode LastVisibleNode {
411      get {
412        var node = FirstVisibleNode;
413        while (node != null && node.NextVisibleNode != null) node = node.NextVisibleNode;
414        return node;
415      }
416    }
417
418    private class ItemTreeNodeComparer : IComparer {
419      public int Compare(object x, object y) {
420        var lhs = (TreeNode)x;
421        var rhs = (TreeNode)y;
422
423        if (lhs.Tag is string && rhs.Tag is string) {
424          return lhs.Name.CompareTo(rhs.Name);
425        } else if (lhs.Tag is string) {
426          return -1;
427        } else
428          return 1;
429      }
430    }
431  }
432}
Note: See TracBrowser for help on using the repository browser.