git.gag.com Git - sw/motorsim/blob - src/com/billkuker/rocketry/motorsim/visual/workbench/WorkbenchTreeModel.java

   1 package com.billkuker.rocketry.motorsim.visual.workbench;
   2
   3 import java.awt.Component;
   4 import java.beans.PropertyChangeEvent;
   5 import java.beans.PropertyChangeListener;
   6 import java.util.Enumeration;
   7
   8 import javax.swing.tree.DefaultMutableTreeNode;
   9 import javax.swing.tree.DefaultTreeModel;
  10 import javax.swing.tree.MutableTreeNode;
  11 import javax.swing.tree.TreeNode;
  12
  13 import com.billkuker.rocketry.motorsim.ChangeListening;
  14 import com.billkuker.rocketry.motorsim.Fuel;
  15 import com.billkuker.rocketry.motorsim.Motor;
  16 import com.billkuker.rocketry.motorsim.grain.MultiGrain;
  17
  18 public class WorkbenchTreeModel extends DefaultTreeModel {
  19
  20         private static final long serialVersionUID = 1L;
  21
  22         //TreeNode root = new DefaultMutableTreeNode("Root");
  23         DefaultMutableTreeNode motors = new DefaultMutableTreeNode("All Motors");
  24         DefaultMutableTreeNode fuel = new DefaultMutableTreeNode("Fuels");
  25
  26         public class MultiGrainNode extends PartNode{
  27                 private static final long serialVersionUID = 1L;
  28                 public MultiGrainNode(MultiGrain part) {
  29                         super(part);
  30                         setAllowsChildren(true);
  31                         add(new PartNode(part.getGrain()));
  32                 }
  33                 @Override
  34                 public void propertyChange(PropertyChangeEvent e) {
  35                         if ( e.getPropertyName().equals("Grain")){
  36                                 remove(0);
  37                                 add(new PartNode(((MultiGrain)getUserObject()).getGrain()));
  38                                 nodesChanged(this, new int[]{0});
  39                         }
  40                         super.propertyChange(e);
  41                 }
  42         }
  43
  44         public class FuelNode extends DefaultMutableTreeNode{
  45                 private static final long serialVersionUID = 1L;
  46                 Fuel f;
  47                 public FuelNode(Component c, Fuel f){
  48                         super(c, false);
  49                         this.f = f;
  50                 }
  51
  52                 @Override
  53                 public Component getUserObject(){
  54                         return (Component)super.getUserObject();
  55                 }
  56
  57                 public Fuel getFuel(){
  58                         return f;
  59                 }
  60         }
  61
  62         public class FuelEditNode extends FuelNode {
  63                 private static final long serialVersionUID = 1L;
  64
  65                 public FuelEditNode(SRFuelEditor sr){
  66                         super(sr, sr.getFuel());
  67                         sr.getFuel().addPropertyChangeListener(new PropertyChangeListener(){
  68
  69                                 @Override
  70                                 public void propertyChange(PropertyChangeEvent evt) {
  71                                         nodeChanged(FuelEditNode.this);
  72                                 }});
  73                 }
  74
  75                 @Override
  76                 public SRFuelEditor getUserObject(){
  77                         return (SRFuelEditor)super.getUserObject();
  78                 }
  79
  80         }
  81
  82         public class PartNode extends DefaultMutableTreeNode implements PropertyChangeListener {
  83                 private static final long serialVersionUID = 1L;
  84
  85                 public PartNode(Object part) {
  86                         super(part, false);
  87                         if (part instanceof ChangeListening.Subject) {
  88                                 ((ChangeListening.Subject) part).addPropertyChangeListener(this);
  89                         }
  90                 }
  91
  92                 @Override
  93                 public void propertyChange(PropertyChangeEvent e) {
  94                         nodeChanged(this);
  95                 }
  96
  97         }
  98
  99         public class MotorNode extends PartNode implements PropertyChangeListener {
 100                 private static final long serialVersionUID = 1L;
 101                 Motor motor;
 102                 PartNode cn, nn, gn, fn;
 103
 104                 public MotorNode(Motor m) {
 105                         super(m);
 106                         setAllowsChildren(true);
 107                         motor = m;
 108                         add( cn = new PartNode(m.getChamber()));
 109                         add( nn = new PartNode(m.getNozzle()));
 110                         if ( m.getGrain() instanceof MultiGrain ){
 111                                 gn = new MultiGrainNode(((MultiGrain)m.getGrain()));
 112                         } else {
 113                                 gn = new PartNode(m.getGrain());
 114                         }
 115                         add(gn);
 116                         if (m instanceof ChangeListening.Subject) {
 117                                 ((ChangeListening.Subject) m).addPropertyChangeListener(this);
 118                         }
 119                 }
 120
 121                 @Override
 122                 public Motor getUserObject(){
 123                         return (Motor)super.getUserObject();
 124                 }
 125
 126                 @Override
 127                 public void propertyChange(PropertyChangeEvent e) {
 128                                 nodeChanged(this);
 129                         super.propertyChange(e);
 130                 }
 131
 132         }
 133
 134         public WorkbenchTreeModel() {
 135                 super(new DefaultMutableTreeNode("Root"), true);
 136                 getRoot().add(motors);
 137                 getRoot().add(fuel);
 138         }
 139
 140         @Override
 141         public DefaultMutableTreeNode getRoot(){
 142                 return (DefaultMutableTreeNode)super.getRoot();
 143         }
 144
 145         public DefaultMutableTreeNode getMotors(){
 146                 return motors;
 147         }
 148
 149         public DefaultMutableTreeNode getFuels(){
 150                 return fuel;
 151         }
 152
 153         public void addMotor(Motor m){
 154                 DefaultMutableTreeNode root = getRoot();
 155                 motors.add(new MotorNode(m));
 156                 nodesWereInserted(motors, new int[]{motors.getChildCount()-1});
 157
 158         }
 159
 160         @SuppressWarnings("unchecked")
 161         public void removeMotor(Motor m){
 162                 Enumeration<TreeNode> e = motors.children();
 163                 while ( e.hasMoreElements() ){
 164                         TreeNode n = e.nextElement();
 165                         if ( n instanceof MotorNode ){
 166                                 if ( ((MotorNode)n).getUserObject() == m ){
 167                                         removeNodeFromParent((MotorNode)n);
 168                                 }
 169                         }
 170                 }
 171         }
 172
 173 }