Coverage Report

 package org.jtheque.core.managers.view.impl.components.menu;
 
 /*
  * This file is part of JTheque.
  *
  * JTheque is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License.
  *
  * JTheque is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with JTheque.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 import org.jtheque.core.managers.Managers;
 import org.jtheque.core.managers.feature.Feature;
 import org.jtheque.core.managers.feature.FeatureEvent;
 import org.jtheque.core.managers.feature.FeatureListener;
 import org.jtheque.core.managers.feature.IFeatureManager;
 import org.jtheque.core.managers.language.ILanguageManager;
 import org.jtheque.core.managers.resource.IResourceManager;
 import org.jtheque.core.managers.resource.ImageType;
 
 import javax.swing.AbstractButton;
 import javax.swing.Action;
 import javax.swing.JMenu;
 import javax.swing.JMenuBar;
 import javax.swing.JMenuItem;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
 /**
  * A menu bar for the main view.
  *
  * @author Baptiste Wicht
  */
 public final class JMenuBarJTheque extends JMenuBar implements FeatureListener {
     private final Comparator<Feature> featureComparator = new ByPositionComparator();
 
     /**
      * A comparator to sort the Features by position.
      *
      * @author Baptiste Wicht
      */
     private static final class ByPositionComparator implements Comparator<Feature> {
         @Override
         public int compare(Feature feature, Feature other) {
             return feature.getPosition().compareTo(other.getPosition());
         }
     }
 
     /**
      * Construct a new JMenuBarJTheque.
      */
     public JMenuBarJTheque() {
         super();
 
         buildMenu();
     }
 
     /**
      * Build the menu.
      */
     private void buildMenu() {
         List<Feature> features = new ArrayList<Feature>(Managers.getManager(IFeatureManager.class).getFeatures());
 
         Collections.sort(features, featureComparator);
 
         for (Feature feature : features) {
             if (!feature.getSubFeatures().isEmpty()) {
                 addFeature(feature);
             }
         }
 
         Managers.getManager(IFeatureManager.class).addFeatureListener(this);
     }
 
 
     /**
      * Add a feature.
      *
      * @param feature The feature to add.
      */
     private void addFeature(Feature feature) {
         JMenu menu = new JThequeMenu(feature.getTitleKey());
 
         List<Feature> subFeatures = new ArrayList<Feature>(feature.getSubFeatures());
 
         Collections.sort(subFeatures, featureComparator);
 
         for (Feature subFeature : subFeatures) {
             addFeature(menu, subFeature);
         }
 
         add(menu);
     }
 
     /**
      * Add a feature.
      *
      * @param menu    The JMenu.
      * @param feature The feature.
      */
     private void addFeature(JMenu menu, Feature feature) {
         switch (feature.getType()) {
             case ACTION:
                 addMenuItem(menu, feature);
 
                 break;
             case SEPARATED_ACTION:
                 addSeparator(menu);
                 addMenuItem(menu, feature);
 
                 break;
             case SEPARATED_ACTIONS:
                 addSeparator(menu);
                 addActions(menu, feature);
 
                 break;
             case ACTIONS:
                 addActions(menu, feature);
 
                 break;
         }
     }
 
     /**
      * Add a menu item to the menu.
      *
      * @param menu    The menu to add the item to.
      * @param feature The feature to add to the menu.
      */
     private static void addMenuItem(JMenu menu, Feature feature) {
         menu.add(new JThequeMenuItem(feature.getAction()));
     }
 
     /**
      * Add actions to the menu.
      *
      * @param menu    The menu to add the actions to.
      * @param feature The feature to add to the menu.
      */
     private void addActions(JMenu menu, Feature feature) {
         JMenu subMenu = new JThequeMenu(feature.getTitleKey());
 
         if (feature.getIcon() != null) {
             subMenu.setIcon(Managers.getManager(IResourceManager.class).getIcon(feature.getBaseName(), feature.getIcon(), ImageType.PNG));
         }
 
         for (Feature subFeature : feature.getSubFeatures()) {
             addFeature(subMenu, subFeature);
         }
 
         menu.add(subMenu);
     }
 
     /**
      * Add a separator to the menu.
      *
      * @param menu The menu.
      */
     private static void addSeparator(JMenu menu) {
         if (menu.getItemCount() > 0) {
             menu.addSeparator();
         }
     }
 
     @Override
     public void featureAdded(FeatureEvent event) {
         addFeature(event.getFeature());
     }
 
     @Override
     public void featureRemoved(FeatureEvent event) {
         for (int i = 0; i < getMenuCount(); i++) {
             JMenu menu = getMenu(i);
 
             if (isCorrespondingMenu(event.getFeature(), menu)) {
                 remove(menu);
 
                 break;
             }
         }
     }
 
     @Override
     public void subFeatureAdded(FeatureEvent event) {
         for (int i = 0; i < getMenuCount(); i++) {
             JMenu menu = getMenu(i);
 
             if (isCorrespondingMenu(event.getFeature(), menu)) {
                 menu.removeAll();
 
                 List<Feature> subFeatures = new ArrayList<Feature>(event.getFeature().getSubFeatures());
 
                 Collections.sort(subFeatures, featureComparator);
 
                 for (Feature subFeature : subFeatures) {
                     addFeature(menu, subFeature);
                 }
 
                 break;
             }
         }
     }
 
     /**
      * Indicate if the menu correspond to the feature
      *
      * @param feature The feature to test.
      * @param menu    The menu to test.
      * @return true if the menu is corresponding to the feature else false.
      */
     private static boolean isCorrespondingMenu(Feature feature, AbstractButton menu) {
         return menu != null && menu.getText().equals(Managers.getManager(ILanguageManager.class).getMessage(
                 feature.getTitleKey()));
     }
 
     @Override
     public void subFeatureRemoved(FeatureEvent event) {
         for (int i = 0; i < getMenuCount(); i++) {
             JMenu menu = getMenu(i);
 
             if (isCorrespondingMenu(event.getFeature(), menu)) {
                 removeMenu(event, menu);
 
                 break;
             }
         }
     }
 
     /**
      * Remove the feature of the event from the menu.
      *
      * @param event The event.
      * @param menu  The menu to the remove the menu from.
      */
     private void removeMenu(FeatureEvent event, JMenu menu) {
         String subtitle = getSubtitle(event);
 
         for (int z = 0; z < menu.getItemCount(); z++) {
             JMenuItem item = menu.getItem(z);
 
             //Perhaps, it's a separator
             if (item != null) {
                 if (item.getAction() != null && item.getAction().getValue(Action.NAME).equals(subtitle)) {
                     menu.remove(item);
                 } else if (item.getText() != null && item.getText().equals(subtitle)) {
                     menu.remove(item);
                 }
 
                 clearMenu(menu);
             }
         }
     }
 
     /**
      * Clear the menu.
      *
      * @param menu The menu to clear.
      */
     private void clearMenu(JMenu menu) {
         if (menu.getItemCount() <= 0) {
             remove(menu);
         } else if (menu.getItem(0) == null) {
             menu.remove(0);
         }
     }
 
     /**
      * Return the title of the sub feature of the event.
      *
      * @param event The feature event.
      * @return The title of the sub feature of the event.
      */
     private static String getSubtitle(FeatureEvent event) {
         if (event.getSubFeature().getAction() == null) {
             return Managers.getManager(ILanguageManager.class).getMessage(event.getSubFeature().getTitleKey());
         } else {
             return (String) event.getSubFeature().getAction().getValue(Action.NAME);
         }
     }
 }

1		package org.jtheque.core.managers.view.impl.components.menu;
2
3		/*
4		* This file is part of JTheque.
5		*
6		* JTheque is free software: you can redistribute it and/or modify
7		* it under the terms of the GNU General Public License as published by
8		* the Free Software Foundation, either version 3 of the License.
9		*
10		* JTheque is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		* GNU General Public License for more details.
14		*
15		* You should have received a copy of the GNU General Public License
16		* along with JTheque. If not, see <http://www.gnu.org/licenses/>.
17		*/
18
19		import org.jtheque.core.managers.Managers;
20		import org.jtheque.core.managers.feature.Feature;
21		import org.jtheque.core.managers.feature.FeatureEvent;
22		import org.jtheque.core.managers.feature.FeatureListener;
23		import org.jtheque.core.managers.feature.IFeatureManager;
24		import org.jtheque.core.managers.language.ILanguageManager;
25		import org.jtheque.core.managers.resource.IResourceManager;
26		import org.jtheque.core.managers.resource.ImageType;
27
28		import javax.swing.AbstractButton;
29		import javax.swing.Action;
30		import javax.swing.JMenu;
31		import javax.swing.JMenuBar;
32		import javax.swing.JMenuItem;
33		import java.util.ArrayList;
34		import java.util.Collections;
35		import java.util.Comparator;
36		import java.util.List;
37
38		/**
39		* A menu bar for the main view.
40		*
41		* @author Baptiste Wicht
42		*/
43		public final class JMenuBarJTheque extends JMenuBar implements FeatureListener {
44	0	private final Comparator<Feature> featureComparator = new ByPositionComparator();
45
46		/**
47		* A comparator to sort the Features by position.
48		*
49		* @author Baptiste Wicht
50		*/
51	0	private static final class ByPositionComparator implements Comparator<Feature> {
52		@Override
53		public int compare(Feature feature, Feature other) {
54	0	return feature.getPosition().compareTo(other.getPosition());
55		}
56		}
57
58		/**
59		* Construct a new JMenuBarJTheque.
60		*/
61		public JMenuBarJTheque() {
62	0	super();
63
64	0	buildMenu();
65	0	}
66
67		/**
68		* Build the menu.
69		*/
70		private void buildMenu() {
71	0	List<Feature> features = new ArrayList<Feature>(Managers.getManager(IFeatureManager.class).getFeatures());
72
73	0	Collections.sort(features, featureComparator);
74
75	0	for (Feature feature : features) {
76	0	if (!feature.getSubFeatures().isEmpty()) {
77	0	addFeature(feature);
78		}
79		}
80
81	0	Managers.getManager(IFeatureManager.class).addFeatureListener(this);
82	0	}
83
84
85		/**
86		* Add a feature.
87		*
88		* @param feature The feature to add.
89		*/
90		private void addFeature(Feature feature) {
91	0	JMenu menu = new JThequeMenu(feature.getTitleKey());
92
93	0	List<Feature> subFeatures = new ArrayList<Feature>(feature.getSubFeatures());
94
95	0	Collections.sort(subFeatures, featureComparator);
96
97	0	for (Feature subFeature : subFeatures) {
98	0	addFeature(menu, subFeature);
99		}
100
101	0	add(menu);
102	0	}
103
104		/**
105		* Add a feature.
106		*
107		* @param menu The JMenu.
108		* @param feature The feature.
109		*/
110		private void addFeature(JMenu menu, Feature feature) {
111	0	switch (feature.getType()) {
112		case ACTION:
113	0	addMenuItem(menu, feature);
114
115	0	break;
116		case SEPARATED_ACTION:
117	0	addSeparator(menu);
118	0	addMenuItem(menu, feature);
119
120	0	break;
121		case SEPARATED_ACTIONS:
122	0	addSeparator(menu);
123	0	addActions(menu, feature);
124
125	0	break;
126		case ACTIONS:
127	0	addActions(menu, feature);
128
129		break;
130		}
131	0	}
132
133		/**
134		* Add a menu item to the menu.
135		*
136		* @param menu The menu to add the item to.
137		* @param feature The feature to add to the menu.
138		*/
139		private static void addMenuItem(JMenu menu, Feature feature) {
140	0	menu.add(new JThequeMenuItem(feature.getAction()));
141	0	}
142
143		/**
144		* Add actions to the menu.
145		*
146		* @param menu The menu to add the actions to.
147		* @param feature The feature to add to the menu.
148		*/
149		private void addActions(JMenu menu, Feature feature) {
150	0	JMenu subMenu = new JThequeMenu(feature.getTitleKey());
151
152	0	if (feature.getIcon() != null) {
153	0	subMenu.setIcon(Managers.getManager(IResourceManager.class).getIcon(feature.getBaseName(), feature.getIcon(), ImageType.PNG));
154		}
155
156	0	for (Feature subFeature : feature.getSubFeatures()) {
157	0	addFeature(subMenu, subFeature);
158		}
159
160	0	menu.add(subMenu);
161	0	}
162
163		/**
164		* Add a separator to the menu.
165		*
166		* @param menu The menu.
167		*/
168		private static void addSeparator(JMenu menu) {
169	0	if (menu.getItemCount() > 0) {
170	0	menu.addSeparator();
171		}
172	0	}
173
174		@Override
175		public void featureAdded(FeatureEvent event) {
176	0	addFeature(event.getFeature());
177	0	}
178
179		@Override
180		public void featureRemoved(FeatureEvent event) {
181	0	for (int i = 0; i < getMenuCount(); i++) {
182	0	JMenu menu = getMenu(i);
183
184	0	if (isCorrespondingMenu(event.getFeature(), menu)) {
185	0	remove(menu);
186
187	0	break;
188		}
189		}
190	0	}
191
192		@Override
193		public void subFeatureAdded(FeatureEvent event) {
194	0	for (int i = 0; i < getMenuCount(); i++) {
195	0	JMenu menu = getMenu(i);
196
197	0	if (isCorrespondingMenu(event.getFeature(), menu)) {
198	0	menu.removeAll();
199
200	0	List<Feature> subFeatures = new ArrayList<Feature>(event.getFeature().getSubFeatures());
201
202	0	Collections.sort(subFeatures, featureComparator);
203
204	0	for (Feature subFeature : subFeatures) {
205	0	addFeature(menu, subFeature);
206		}
207
208	0	break;
209		}
210		}
211	0	}
212
213		/**
214		* Indicate if the menu correspond to the feature
215		*
216		* @param feature The feature to test.
217		* @param menu The menu to test.
218		* @return true if the menu is corresponding to the feature else false.
219		*/
220		private static boolean isCorrespondingMenu(Feature feature, AbstractButton menu) {
221	0	return menu != null && menu.getText().equals(Managers.getManager(ILanguageManager.class).getMessage(
222		feature.getTitleKey()));
223		}
224
225		@Override
226		public void subFeatureRemoved(FeatureEvent event) {
227	0	for (int i = 0; i < getMenuCount(); i++) {
228	0	JMenu menu = getMenu(i);
229
230	0	if (isCorrespondingMenu(event.getFeature(), menu)) {
231	0	removeMenu(event, menu);
232
233	0	break;
234		}
235		}
236	0	}
237
238		/**
239		* Remove the feature of the event from the menu.
240		*
241		* @param event The event.
242		* @param menu The menu to the remove the menu from.
243		*/
244		private void removeMenu(FeatureEvent event, JMenu menu) {
245	0	String subtitle = getSubtitle(event);
246
247	0	for (int z = 0; z < menu.getItemCount(); z++) {
248	0	JMenuItem item = menu.getItem(z);
249
250		//Perhaps, it's a separator
251	0	if (item != null) {
252	0	if (item.getAction() != null && item.getAction().getValue(Action.NAME).equals(subtitle)) {
253	0	menu.remove(item);
254	0	} else if (item.getText() != null && item.getText().equals(subtitle)) {
255	0	menu.remove(item);
256		}
257
258	0	clearMenu(menu);
259		}
260		}
261	0	}
262
263		/**
264		* Clear the menu.
265		*
266		* @param menu The menu to clear.
267		*/
268		private void clearMenu(JMenu menu) {
269	0	if (menu.getItemCount() <= 0) {
270	0	remove(menu);
271	0	} else if (menu.getItem(0) == null) {
272	0	menu.remove(0);
273		}
274	0	}
275
276		/**
277		* Return the title of the sub feature of the event.
278		*
279		* @param event The feature event.
280		* @return The title of the sub feature of the event.
281		*/
282		private static String getSubtitle(FeatureEvent event) {
283	0	if (event.getSubFeature().getAction() == null) {
284	0	return Managers.getManager(ILanguageManager.class).getMessage(event.getSubFeature().getTitleKey());
285		} else {
286	0	return (String) event.getSubFeature().getAction().getValue(Action.NAME);
287		}
288		}
289		}