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