View Javadoc

1   package de.matthias_burbach.deputy.swing;
2   
3   import java.util.Enumeration;
4   import java.util.Iterator;
5   
6   import javax.swing.tree.DefaultTreeModel;
7   
8   import de.matthias_burbach.deputy.core.project.Project;
9   import de.matthias_burbach.deputy.core.rule.DeprecationRule;
10  import de.matthias_burbach.deputy.core.rule.EnforcementRule;
11  import de.matthias_burbach.deputy.core.rule.RemovalRule;
12  import de.matthias_burbach.deputy.core.rule.ReplacementRule;
13  import de.matthias_burbach.deputy.core.rule.RetentionRule;
14  import de.matthias_burbach.deputy.core.rule.Rule;
15  import de.matthias_burbach.deputy.core.rule.RuleSetChangeListener;
16  
17  /***
18   * @author Matthias Burbach
19   */
20  public class RuleSetTreeNode
21      extends BaseMutableTreeNode
22      implements RuleSetChangeListener {
23  
24      /***
25       * The top project whose rule set to display.
26       */
27      private Project project;
28  
29      /***
30       * The tree model to delegate change operations to.
31       */
32      private DefaultTreeModel treeModel;
33  
34      /***
35       * @param project The top project whose rule set to display.
36       * @param treeModel The tree model to delegate change operations to.
37       */
38      public RuleSetTreeNode(
39              final Project project,
40              final DefaultTreeModel treeModel) {
41          this.project = project;
42          this.project.getRuleSet().addChangeListener(this);
43          this.treeModel = treeModel;
44      }
45  
46      /*
47       * (non-Javadoc)
48       * @see de.matthias_burbach.deputy.swing.BaseMutableTreeNode#initChildren()
49       */
50      /***
51       * {@inheritDoc}
52       */
53      protected void initChildren() {
54          Iterator rules = project.getRuleSet().getEnforcementRules().iterator();
55          while (rules.hasNext()) {
56              EnforcementRule rule = (EnforcementRule) rules.next();
57              EnforcementRuleTreeNode childNode =
58                  new EnforcementRuleTreeNode(rule);
59              add(childNode);
60          }
61  
62          rules = project.getRuleSet().getDeprecationRules().iterator();
63          while (rules.hasNext()) {
64              DeprecationRule rule = (DeprecationRule) rules.next();
65              DeprecationRuleTreeNode childNode =
66                  new DeprecationRuleTreeNode(
67                      rule);
68              add(childNode);
69          }
70  
71          rules = project.getRuleSet().getReplacementRules().iterator();
72          while (rules.hasNext()) {
73              ReplacementRule rule = (ReplacementRule) rules.next();
74              ReplacementRuleTreeNode childNode =
75                  new ReplacementRuleTreeNode(rule);
76              add(childNode);
77          }
78  
79          rules = project.getRuleSet().getRemovalRules().iterator();
80          while (rules.hasNext()) {
81              RemovalRule rule = (RemovalRule) rules.next();
82              RemovalRuleTreeNode childNode =
83                  new RemovalRuleTreeNode(rule);
84              add(childNode);
85          }
86  
87          rules = project.getRuleSet().getRetentionRules().iterator();
88          while (rules.hasNext()) {
89              RetentionRule rule = (RetentionRule) rules.next();
90              RetentionRuleTreeNode childNode =
91                  new RetentionRuleTreeNode(rule);
92              add(childNode);
93          }
94      }
95  
96      /*
97       * (non-Javadoc)
98       * @see de.matthias_burbach.deputy.core.RuleSetChangeListener
99       *          #addedRule(de.matthias_burbach.deputy.core.Rule, int)
100      */
101     /***
102      * {@inheritDoc}
103      */
104     public void addedRule(
105             final Rule addedRule,
106             final int index) {
107         if (childrenAreInitialized()) {
108             RuleTreeNode childNode = null;
109             if (addedRule instanceof EnforcementRule) {
110                 childNode =
111                     new EnforcementRuleTreeNode(
112                         (EnforcementRule) addedRule);
113             } else if (addedRule instanceof DeprecationRule) {
114                 childNode =
115                     new DeprecationRuleTreeNode(
116                         (DeprecationRule) addedRule);
117             } else if (addedRule instanceof ReplacementRule) {
118                 childNode =
119                     new ReplacementRuleTreeNode(
120                         (ReplacementRule) addedRule);
121             } else if (addedRule instanceof RemovalRule) {
122                 childNode =
123                     new RemovalRuleTreeNode(
124                         (RemovalRule) addedRule);
125             } else if (addedRule instanceof RetentionRule) {
126                 childNode =
127                     new RetentionRuleTreeNode(
128                         (RetentionRule) addedRule);
129             }
130             if (childNode != null) {
131                 treeModel.insertNodeInto(childNode, this, index);
132             }
133         }
134     }
135 
136     /*
137      * (non-Javadoc)
138      * @see de.matthias_burbach.deputy.core.RuleSetChangeListener
139      *          #removedRule(de.matthias_burbach.deputy.core.Rule, int)
140      */
141     /***
142      * {@inheritDoc}
143      */
144     public void removedRule(final Rule removedRule) {
145         if (childrenAreInitialized()) {
146             RuleTreeNode childNode
147                 = findChildNodeForRule(removedRule);
148             treeModel.removeNodeFromParent(childNode);
149         }
150     }
151 
152     /*(non-Javadoc)
153      * @see de.matthias_burbach.deputy.core.RuleSetChangeListener
154      *          #changedDefaultRule()
155      */
156     /***
157      * {@inheritDoc}
158      */
159     public void changedDefaultRule() {
160         treeModel.nodeChanged(this);
161     }
162 
163     /***
164      * @param rule The rule to find the corresponding child node for.
165      * @return The child node representing the rule or <code>null</code>.
166      */
167     private RuleTreeNode findChildNodeForRule(final Rule rule) {
168         RuleTreeNode result = null;
169         for (Enumeration nodes = children(); nodes.hasMoreElements();) {
170             RuleTreeNode childNode =
171                 (RuleTreeNode) nodes.nextElement();
172             if (childNode.getRule().equals(rule)) {
173                 result = childNode;
174                 break;
175             }
176         }
177         return result;
178     }
179 
180     /*(non-Javadoc)
181      * @see java.lang.Object#toString()
182      */
183     /***
184      * {@inheritDoc}
185      */
186     public String toString() {
187         String result =
188             "rules [default is " + project.getRuleSet().getDefaultRule() + "]";
189         return result;
190     }
191 }