git.gag.com Git - debian/openrocket/blob - src/net/sf/openrocket/gui/dialogs/optimization/SimulationModifierTree.java

   1 package net.sf.openrocket.gui.dialogs.optimization;
   2
   3 import java.awt.Color;
   4 import java.awt.Component;
   5 import java.awt.Font;
   6 import java.util.Enumeration;
   7 import java.util.List;
   8 import java.util.Map;
   9
  10 import javax.swing.JTree;
  11 import javax.swing.tree.DefaultMutableTreeNode;
  12 import javax.swing.tree.DefaultTreeCellRenderer;
  13 import javax.swing.tree.TreePath;
  14
  15 import net.sf.openrocket.gui.components.BasicTree;
  16 import net.sf.openrocket.gui.main.ComponentIcons;
  17 import net.sf.openrocket.optimization.rocketoptimization.SimulationModifier;
  18 import net.sf.openrocket.rocketcomponent.Rocket;
  19 import net.sf.openrocket.rocketcomponent.RocketComponent;
  20
  21 /**
  22  * A tree that displays the simulation modifiers in a tree structure.
  23  * <p>
  24  * All nodes in the model are instances of DefaultMutableTreeNode.  The user objects
  25  * within are either of type RocketComponent, String or SimulationModifier.
  26  *
  27  * @author Sampo Niskanen <sampo.niskanen@iki.fi>
  28  */
  29 public class SimulationModifierTree extends BasicTree {
  30
  31         /**
  32          * Sole constructor.
  33          *
  34          * @param rocket                                the rocket.
  35          * @param simulationModifiers   the simulation modifiers, ordered and mapped by components
  36          */
  37         public SimulationModifierTree(Rocket rocket, Map<Object, List<SimulationModifier>> simulationModifiers) {
  38                 super(createModifierTree(rocket, simulationModifiers));
  39
  40                 this.setCellRenderer(new ComponentModifierTreeRenderer());
  41                 expandComponents();
  42         }
  43
  44
  45
  46         private static DefaultMutableTreeNode createModifierTree(Rocket rocket,
  47                         Map<Object, List<SimulationModifier>> simulationModifiers) {
  48
  49                 DefaultMutableTreeNode baseNode = new DefaultMutableTreeNode(rocket);
  50                 populateTree(baseNode, rocket, simulationModifiers);
  51
  52                 return baseNode;
  53         }
  54
  55
  56         private static void populateTree(DefaultMutableTreeNode node, RocketComponent component,
  57                         Map<Object, List<SimulationModifier>> simulationModifiers) {
  58
  59                 // Add modifiers (if any)
  60                 List<SimulationModifier> modifiers = simulationModifiers.get(component);
  61                 if (modifiers != null) {
  62                         DefaultMutableTreeNode modifierNode;
  63
  64                         if (component.getChildCount() > 0) {
  65                                 modifierNode = new DefaultMutableTreeNode("Optimization parameters");
  66                                 node.add(modifierNode);
  67                         } else {
  68                                 modifierNode = node;
  69                         }
  70
  71                         for (SimulationModifier m : modifiers) {
  72                                 modifierNode.add(new DefaultMutableTreeNode(m));
  73                         }
  74                 }
  75
  76                 // Add child components
  77                 for (RocketComponent c : component.getChildren()) {
  78                         DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(c);
  79                         node.add(newNode);
  80                         populateTree(newNode, c, simulationModifiers);
  81                 }
  82
  83         }
  84
  85
  86         @SuppressWarnings("rawtypes")
  87         private void expandComponents() {
  88                 DefaultMutableTreeNode baseNode = (DefaultMutableTreeNode) this.getModel().getRoot();
  89
  90                 Enumeration enumeration = baseNode.breadthFirstEnumeration();
  91
  92                 while (enumeration.hasMoreElements()) {
  93                         DefaultMutableTreeNode node = (DefaultMutableTreeNode) enumeration.nextElement();
  94                         Object object = node.getUserObject();
  95                         if (object instanceof RocketComponent) {
  96                                 this.makeVisible(new TreePath(node.getPath()));
  97                         }
  98                 }
  99         }
 100
 101
 102
 103
 104         public class ComponentModifierTreeRenderer extends DefaultTreeCellRenderer {
 105                 private Font componentFont;
 106                 private Font stringFont;
 107                 private Font modifierFont;
 108
 109                 @Override
 110                 public Component getTreeCellRendererComponent(
 111                                 JTree tree,
 112                                 Object value,
 113                                 boolean sel,
 114                                 boolean expanded,
 115                                 boolean leaf,
 116                                 int row,
 117                                 boolean hasFocus2) {
 118
 119                         super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus2);
 120
 121                         if (componentFont == null) {
 122                                 makeFonts();
 123                         }
 124
 125
 126                         // Customize based on line type
 127
 128                         Object object = ((DefaultMutableTreeNode) value).getUserObject();
 129
 130                         // Set icon (for rocket components, null for others)
 131                         setIcon(ComponentIcons.getSmallIcon(object.getClass()));
 132
 133
 134                         // Set text color/style
 135                         if (object instanceof RocketComponent) {
 136                                 setForeground(Color.GRAY);
 137                                 setFont(componentFont);
 138                         } else if (object instanceof String) {
 139                                 setForeground(Color.GRAY);
 140                                 setFont(stringFont);
 141                         } else if (object instanceof SimulationModifier) {
 142                                 setForeground(Color.BLACK);
 143                                 setFont(modifierFont);
 144                                 setText(((SimulationModifier) object).getName());
 145                         }
 146
 147                         return this;
 148                 }
 149
 150                 private void makeFonts() {
 151                         Font font = getFont();
 152                         componentFont = font.deriveFont(Font.ITALIC);
 153                         stringFont = font;
 154                         modifierFont = font.deriveFont(Font.BOLD);
 155                 }
 156
 157         }
 158
 159 }