Lines 27-33
Link Here
|
27 |
import javax.swing.JComponent; |
27 |
import javax.swing.JComponent; |
28 |
import javax.swing.SwingUtilities; |
28 |
import javax.swing.SwingUtilities; |
29 |
|
29 |
|
30 |
import org.netbeans.modules.viewmodel.CompoundModel; |
|
|
31 |
import org.netbeans.modules.viewmodel.TreeModelNode; |
30 |
import org.netbeans.modules.viewmodel.TreeModelNode; |
32 |
import org.netbeans.modules.viewmodel.TreeTable; |
31 |
import org.netbeans.modules.viewmodel.TreeTable; |
33 |
|
32 |
|
Lines 54-64
Link Here
|
54 |
*/ |
53 |
*/ |
55 |
public final class Models { |
54 |
public final class Models { |
56 |
|
55 |
|
57 |
public static final TreeModel EMPTY_TREE_MODEL = new EmptyTreeModel (); |
56 |
/** |
58 |
public static final NodeModel EMPTY_NODE_MODEL = new EmptyNodeModel (); |
57 |
* Empty model - returns default root node with no children. |
59 |
public static final TableModel EMPTY_TABLE_MODEL = new EmptyTableModel (); |
58 |
*/ |
60 |
public static final NodeActionsProvider EMPTY_NODE_ACTIONS_PROVIDER = |
59 |
public static CompoundModel EMPTY_MODEL = createCompoundModel |
61 |
new EmptyNodeActionsProvider (); |
60 |
(new ArrayList ()); |
|
|
61 |
|
62 |
|
62 |
|
63 |
public static int MULTISELECTION_TYPE_EXACTLY_ONE = 1; |
63 |
public static int MULTISELECTION_TYPE_EXACTLY_ONE = 1; |
64 |
public static int MULTISELECTION_TYPE_ALL = 2; |
64 |
public static int MULTISELECTION_TYPE_ALL = 2; |
Lines 85-107
Link Here
|
85 |
* @return new instance of complete model |
85 |
* @return new instance of complete model |
86 |
*/ |
86 |
*/ |
87 |
public static JComponent createView ( |
87 |
public static JComponent createView ( |
88 |
TreeModel treeModel, |
88 |
CompoundModel compoundModel |
89 |
NodeModel nodeModel, |
|
|
90 |
TableModel tableModel, |
91 |
NodeActionsProvider nodeActionsProvider, |
92 |
List columnModels |
93 |
) { |
89 |
) { |
94 |
TreeTable tt = new TreeTable (); |
90 |
TreeTable tt = new TreeTable (); |
95 |
if (treeModel != null) { |
91 |
tt.setModel (compoundModel); |
96 |
CompoundModel cm = new CompoundModel ( |
|
|
97 |
treeModel, |
98 |
nodeModel, |
99 |
nodeActionsProvider, |
100 |
columnModels, |
101 |
tableModel |
102 |
); |
103 |
tt.setModel (cm); |
104 |
} |
105 |
return tt; |
92 |
return tt; |
106 |
} |
93 |
} |
107 |
|
94 |
|
Lines 117-181
Link Here
|
117 |
*/ |
104 |
*/ |
118 |
public static void setModelsToView ( |
105 |
public static void setModelsToView ( |
119 |
final JComponent view, |
106 |
final JComponent view, |
120 |
TreeModel treeModel, |
107 |
final CompoundModel compoundModel |
121 |
NodeModel nodeModel, |
|
|
122 |
TableModel tableModel, |
123 |
NodeActionsProvider nodeActionsProvider, |
124 |
List columnModels |
125 |
) { |
108 |
) { |
126 |
if (verbose) { |
109 |
if (verbose) |
127 |
System.out.println (" TreeModel:"); |
110 |
System.out.println (compoundModel); |
128 |
if (treeModel instanceof CompoundTreeModel) |
|
|
129 |
System.out.println (((CompoundTreeModel) treeModel).toString (" ")); |
130 |
else |
131 |
System.out.println (" " + treeModel); |
132 |
|
133 |
System.out.println (" NodeModel:"); |
134 |
if (nodeModel instanceof CompoundNodeModel) |
135 |
System.out.println (((CompoundNodeModel) nodeModel).toString (" ")); |
136 |
else |
137 |
if (nodeModel instanceof DelegatingNodeModel) |
138 |
System.out.println (((DelegatingNodeModel) nodeModel).toString (" ")); |
139 |
else |
140 |
System.out.println (" " + nodeModel); |
141 |
|
142 |
System.out.println (" NodeActionsProvider:"); |
143 |
if (nodeActionsProvider instanceof CompoundNodeActionsProvider) |
144 |
System.out.println (((CompoundNodeActionsProvider) nodeActionsProvider).toString (" ")); |
145 |
else |
146 |
if (nodeActionsProvider instanceof DelegatingNodeActionsProvider) |
147 |
System.out.println (((DelegatingNodeActionsProvider) nodeActionsProvider).toString (" ")); |
148 |
else |
149 |
System.out.println (" " + nodeActionsProvider); |
150 |
|
151 |
System.out.println (" ColumnModels:"); |
152 |
int i, k = columnModels.size (); |
153 |
for (i = 0; i < k; i++) |
154 |
System.out.println (" " + columnModels.get (i)); |
155 |
|
156 |
System.out.println (" TableModel:"); |
157 |
if (tableModel instanceof CompoundTableModel) |
158 |
System.out.println (((CompoundTableModel) tableModel).toString (" ")); |
159 |
else |
160 |
if (tableModel instanceof DelegatingTableModel) |
161 |
System.out.println (((DelegatingTableModel) tableModel).toString (" ")); |
162 |
else |
163 |
System.out.println (" " + tableModel); |
164 |
} |
165 |
final CompoundModel cm = new CompoundModel ( |
166 |
treeModel, |
167 |
nodeModel, |
168 |
nodeActionsProvider, |
169 |
columnModels, |
170 |
tableModel |
171 |
); |
172 |
SwingUtilities.invokeLater (new Runnable () { |
111 |
SwingUtilities.invokeLater (new Runnable () { |
173 |
public void run () { |
112 |
public void run () { |
174 |
((TreeTable) view).setModel (cm); |
113 |
((TreeTable) view).setModel (compoundModel); |
175 |
} |
114 |
} |
176 |
}); |
115 |
}); |
177 |
} |
116 |
} |
178 |
|
117 |
|
|
|
118 |
public static CompoundModel createCompoundModel (List models) { |
119 |
List treeModels = new ArrayList (); |
120 |
List treeModelFilters = new ArrayList (); |
121 |
List treeExpansionModels = new ArrayList (); |
122 |
List nodeModels = new ArrayList (); |
123 |
List nodeModelFilters = new ArrayList (); |
124 |
List tableModels = new ArrayList (); |
125 |
List tableModelFilters = new ArrayList (); |
126 |
List nodeActionsProviders = new ArrayList (); |
127 |
List nodeActionsProviderFilters = new ArrayList (); |
128 |
List columnModels = new ArrayList (); |
129 |
|
130 |
// 1) sort models |
131 |
Iterator it = models.iterator (); |
132 |
while (it.hasNext ()) { |
133 |
Object model = it.next (); |
134 |
if (model instanceof TreeModel) |
135 |
treeModels.add (model); |
136 |
if (model instanceof TreeModelFilter) |
137 |
treeModelFilters.add (model); |
138 |
if (model instanceof TreeExpansionModel) |
139 |
treeExpansionModels.add (model); |
140 |
if (model instanceof NodeModel) |
141 |
nodeModels.add (model); |
142 |
if (model instanceof NodeModelFilter) |
143 |
nodeModelFilters.add (model); |
144 |
if (model instanceof TableModel) |
145 |
tableModels.add (model); |
146 |
if (model instanceof TableModelFilter) |
147 |
tableModelFilters.add (model); |
148 |
if (model instanceof NodeActionsProvider) |
149 |
nodeActionsProviders.add (model); |
150 |
if (model instanceof NodeActionsProviderFilter) |
151 |
nodeActionsProviderFilters.add (model); |
152 |
if (model instanceof ColumnModel) |
153 |
columnModels.add (model); |
154 |
} |
155 |
|
156 |
if (treeModels.isEmpty ()) treeModels.add (new EmptyTreeModel ()); |
157 |
|
158 |
return new CompoundModel ( |
159 |
createCompoundTreeModel ( |
160 |
new DelegatingTreeModel (treeModels), |
161 |
treeModelFilters |
162 |
), |
163 |
new DelegatingTreeExpansionModel (treeExpansionModels), |
164 |
createCompoundNodeModel ( |
165 |
new DelegatingNodeModel (nodeModels), |
166 |
nodeModelFilters |
167 |
), |
168 |
createCompoundNodeActionsProvider ( |
169 |
new DelegatingNodeActionsProvider (nodeActionsProviders), |
170 |
nodeActionsProviderFilters |
171 |
), |
172 |
columnModels, |
173 |
createCompoundTableModel ( |
174 |
new DelegatingTableModel (tableModels), |
175 |
tableModelFilters |
176 |
) |
177 |
); |
178 |
} |
179 |
|
180 |
/** |
181 |
* Returns {@link javax.swing.Action} for given parameters. |
182 |
* |
183 |
* @param displayName a display name for action |
184 |
* @param node a node the action should by applied to |
185 |
* @param performer a performer for action |
186 |
* |
187 |
* @return a new instance of {@link javax.swing.Action} for given parameters |
188 |
*/ |
189 |
public static Action createAction ( |
190 |
String displayName, |
191 |
ActionPerformer performer, |
192 |
int multiselectionType |
193 |
) { |
194 |
return new ActionSupport ( |
195 |
displayName, |
196 |
performer, |
197 |
multiselectionType |
198 |
); |
199 |
} |
200 |
|
201 |
/** |
202 |
* Returns implementation of tree view features for given view. |
203 |
* |
204 |
* @param view a view created by this Models class |
205 |
* @throws UnsupportedOperationException in the case that given |
206 |
* view is not tree view |
207 |
* @return implementation of tree view features |
208 |
*/ |
209 |
public static TreeFeatures treeFeatures (JComponent view) |
210 |
throws UnsupportedOperationException { |
211 |
return new TreeFeatures (view); |
212 |
} |
213 |
|
214 |
|
215 |
// private methods ......................................................... |
216 |
|
179 |
/** |
217 |
/** |
180 |
* Creates {@link org.netbeans.spi.viewmodel.TreeModel} for given TreeModel and |
218 |
* Creates {@link org.netbeans.spi.viewmodel.TreeModel} for given TreeModel and |
181 |
* {@link org.netbeans.spi.viewmodel.TreeModelFilter}. |
219 |
* {@link org.netbeans.spi.viewmodel.TreeModelFilter}. |
Lines 185-191
Link Here
|
185 |
* |
223 |
* |
186 |
* @returns compund tree model |
224 |
* @returns compund tree model |
187 |
*/ |
225 |
*/ |
188 |
public static TreeModel createCompoundTreeModel ( |
226 |
private static TreeModel createCompoundTreeModel ( |
189 |
TreeModel originalTreeModel, |
227 |
TreeModel originalTreeModel, |
190 |
List treeModelFilters |
228 |
List treeModelFilters |
191 |
) { |
229 |
) { |
Lines 208-214
Link Here
|
208 |
* |
246 |
* |
209 |
* @returns compund tree model |
247 |
* @returns compund tree model |
210 |
*/ |
248 |
*/ |
211 |
public static NodeModel createCompoundNodeModel ( |
249 |
private static NodeModel createCompoundNodeModel ( |
212 |
NodeModel originalNodeModel, |
250 |
NodeModel originalNodeModel, |
213 |
List treeNodeModelFilters |
251 |
List treeNodeModelFilters |
214 |
) { |
252 |
) { |
Lines 231-237
Link Here
|
231 |
* |
269 |
* |
232 |
* @returns compund table model |
270 |
* @returns compund table model |
233 |
*/ |
271 |
*/ |
234 |
public static TableModel createCompoundTableModel ( |
272 |
private static TableModel createCompoundTableModel ( |
235 |
TableModel originalTableModel, |
273 |
TableModel originalTableModel, |
236 |
List tableModelFilters |
274 |
List tableModelFilters |
237 |
) { |
275 |
) { |
Lines 254-260
Link Here
|
254 |
* |
292 |
* |
255 |
* @returns compund node actions provider |
293 |
* @returns compund node actions provider |
256 |
*/ |
294 |
*/ |
257 |
public static NodeActionsProvider createCompoundNodeActionsProvider ( |
295 |
private static NodeActionsProvider createCompoundNodeActionsProvider ( |
258 |
NodeActionsProvider originalNodeActionsProvider, |
296 |
NodeActionsProvider originalNodeActionsProvider, |
259 |
List nodeActionsProviderFilters |
297 |
List nodeActionsProviderFilters |
260 |
) { |
298 |
) { |
Lines 268-384
Link Here
|
268 |
return nap; |
306 |
return nap; |
269 |
} |
307 |
} |
270 |
|
308 |
|
271 |
// /** |
|
|
272 |
// * Creates one {@link org.netbeans.spi.viewmodel.TableModel} |
273 |
// * from given array of TableModels. TableModel asks all underlaying |
274 |
// * models for each concrete parameter, and returns first returned value. |
275 |
// * |
276 |
// * @param originalTableModels a array of original table models |
277 |
// */ |
278 |
// public static TableModel createCompoundTableModel ( |
279 |
// TableModel[] originalTableModels |
280 |
// ) { |
281 |
// return new DelegatingTableModel ( |
282 |
// originalTableModels |
283 |
// ); |
284 |
// } |
285 |
|
286 |
/** |
287 |
* Creates one {@link org.netbeans.spi.viewmodel.TableModel} |
288 |
* from given list of TableModels. TableModel asks all underlaying |
289 |
* models for each concrete parameter, and returns first returned value. |
290 |
* |
291 |
* @param originalTableModels a list of original table models |
292 |
*/ |
293 |
public static TableModel createCompoundTableModel ( |
294 |
List originalTableModels |
295 |
) { |
296 |
return new DelegatingTableModel ( |
297 |
originalTableModels |
298 |
); |
299 |
} |
300 |
|
301 |
// /** |
302 |
// * Creates one {@link org.netbeans.spi.viewmodel.NodeModel} |
303 |
// * from given array of NodeModels. NodeModel asks all underlaying |
304 |
// * models for each concrete parameter, and returns first returned value. |
305 |
// * |
306 |
// * @param originalNodeModels a array of original node models |
307 |
// */ |
308 |
// public static NodeModel createCompoundNodeModel ( |
309 |
// NodeModel[] originalNodeModels |
310 |
// ) { |
311 |
// return new DelegatingNodeModel ( |
312 |
// originalNodeModels |
313 |
// ); |
314 |
// } |
315 |
|
316 |
/** |
317 |
* Creates one {@link org.netbeans.spi.viewmodel.NodeModel} |
318 |
* from given list of NodeModels. NodeModel asks all underlaying |
319 |
* models for each concrete parameter, and returns first returned value. |
320 |
* |
321 |
* @param originalNodeModels a list of original node models |
322 |
*/ |
323 |
public static NodeModel createCompoundNodeModel ( |
324 |
List originalNodeModels |
325 |
) { |
326 |
return new DelegatingNodeModel ( |
327 |
originalNodeModels |
328 |
); |
329 |
} |
330 |
|
331 |
// /** |
332 |
// * Creates one {@link org.netbeans.spi.viewmodel.NodeActionsProvider} |
333 |
// * from given array of NodeActionsProviders. NodeActionsProvider asks all underlaying |
334 |
// * models for each concrete parameter, and returns first returned value. |
335 |
// * |
336 |
// * @param originalNodeActionsProviders a array of original node action providers |
337 |
// */ |
338 |
// public static NodeActionsProvider createCompoundNodeActionsProvider ( |
339 |
// NodeActionsProvider[] originalNodeActionsProviders |
340 |
// ) { |
341 |
// return new DelegatingNodeActionsProvider ( |
342 |
// originalNodeActionsProviders |
343 |
// ); |
344 |
// } |
345 |
|
346 |
/** |
347 |
* Creates one {@link org.netbeans.spi.viewmodel.NodeActionsProvider} |
348 |
* from given list of NodeActionsProviders. NodeActionsProvider asks all underlaying |
349 |
* models for each concrete parameter, and returns first returned value. |
350 |
* |
351 |
* @param originalNodeActionsProviders a list of original node action providers |
352 |
*/ |
353 |
public static NodeActionsProvider createCompoundNodeActionsProvider ( |
354 |
List originalNodeActionsProviders |
355 |
) { |
356 |
return new DelegatingNodeActionsProvider ( |
357 |
originalNodeActionsProviders |
358 |
); |
359 |
} |
360 |
|
361 |
/** |
362 |
* Returns {@link javax.swing.Action} for given parameters. |
363 |
* |
364 |
* @param displayName a display name for action |
365 |
* @param node a node the action should by applied to |
366 |
* @param performer a performer for action |
367 |
* |
368 |
* @return a new instance of {@link javax.swing.Action} for given parameters |
369 |
*/ |
370 |
public static Action createAction ( |
371 |
String displayName, |
372 |
ActionPerformer performer, |
373 |
int multiselectionType |
374 |
) { |
375 |
return new ActionSupport ( |
376 |
displayName, |
377 |
performer, |
378 |
multiselectionType |
379 |
); |
380 |
} |
381 |
|
382 |
|
309 |
|
383 |
// innerclasses ............................................................ |
310 |
// innerclasses ............................................................ |
384 |
|
311 |
|
Lines 809-814
Link Here
|
809 |
n + " " + model; |
736 |
n + " " + model; |
810 |
} |
737 |
} |
811 |
} |
738 |
} |
|
|
739 |
|
740 |
/** |
741 |
* Creates one {@link org.netbeans.spi.viewmodel.TreeModel} |
742 |
* from given list of TreeModels. DelegatingTreeModel asks all underlaying |
743 |
* models for each concrete parameter, and returns first returned value. |
744 |
* |
745 |
* @author Jan Jancura |
746 |
*/ |
747 |
final static class DelegatingTreeModel implements TreeModel { |
748 |
|
749 |
private TreeModel[] models; |
750 |
private HashMap classNameToModel = new HashMap (); |
751 |
|
752 |
|
753 |
/** |
754 |
* Creates new instance of DelegatingTreeModel for given list of |
755 |
* TableModels. |
756 |
* |
757 |
* @param models a list of TableModels |
758 |
*/ |
759 |
DelegatingTreeModel (List models) { |
760 |
this (convert (models)); |
761 |
} |
762 |
|
763 |
private static TreeModel[] convert (List l) { |
764 |
TreeModel[] models = new TreeModel [l.size ()]; |
765 |
return (TreeModel[]) l.toArray (models); |
766 |
} |
767 |
|
768 |
/** |
769 |
* Creates new instance of DelegatingTreeModel for given array of |
770 |
* TableModels. |
771 |
* |
772 |
* @param models a array of TreeModel |
773 |
*/ |
774 |
DelegatingTreeModel (TreeModel[] models) { |
775 |
this.models = models; |
776 |
} |
777 |
|
778 |
/** |
779 |
* Returns the root node of the tree or null, if the tree is empty. |
780 |
* |
781 |
* @return the root node of the tree or null |
782 |
*/ |
783 |
public Object getRoot () { |
784 |
return models [0].getRoot (); |
785 |
} |
786 |
|
787 |
/** |
788 |
* Returns children for given parent on given indexes. |
789 |
* |
790 |
* @param parent a parent of returned nodes |
791 |
* @param from a start index |
792 |
* @param to a end index |
793 |
* |
794 |
* @throws UnknownTypeException if this TreeModel implementation is not |
795 |
* able to resolve children for given node type |
796 |
* |
797 |
* @return children for given parent on given indexes |
798 |
*/ |
799 |
public Object[] getChildren (Object node, int from, int to) |
800 |
throws UnknownTypeException { |
801 |
TreeModel model = (TreeModel) classNameToModel.get ( |
802 |
node.getClass ().getName () |
803 |
); |
804 |
if (model != null) |
805 |
try { |
806 |
return model.getChildren (node, from, to); |
807 |
} catch (UnknownTypeException e) { |
808 |
} |
809 |
int i, k = models.length; |
810 |
for (i = 0; i < k; i++) { |
811 |
try { |
812 |
Object[] v = models [i].getChildren (node, from, to); |
813 |
classNameToModel.put (node.getClass ().getName (), models [i]); |
814 |
return v; |
815 |
} catch (UnknownTypeException e) { |
816 |
} |
817 |
} |
818 |
throw new UnknownTypeException (node); |
819 |
} |
820 |
|
821 |
/** |
822 |
* Returns number of children for given node. |
823 |
* |
824 |
* @param node the parent node |
825 |
* @throws UnknownTypeException if this TreeModel implementation is not |
826 |
* able to resolve children for given node type |
827 |
* |
828 |
* @return true if node is leaf |
829 |
* @since 1.1 |
830 |
*/ |
831 |
public int getChildrenCount (Object node) |
832 |
throws UnknownTypeException { |
833 |
TreeModel model = (TreeModel) classNameToModel.get ( |
834 |
node.getClass ().getName () |
835 |
); |
836 |
if (model != null) |
837 |
try { |
838 |
return model.getChildrenCount (node); |
839 |
} catch (UnknownTypeException e) { |
840 |
} |
841 |
int i, k = models.length; |
842 |
for (i = 0; i < k; i++) { |
843 |
try { |
844 |
int result = models [i].getChildrenCount (node); |
845 |
classNameToModel.put (node.getClass ().getName (), models [i]); |
846 |
return result; |
847 |
} catch (UnknownTypeException e) { |
848 |
} |
849 |
} |
850 |
throw new UnknownTypeException (node); |
851 |
} |
852 |
|
853 |
/** |
854 |
* Returns true if node is leaf. |
855 |
* |
856 |
* @throws UnknownTypeException if this TreeModel implementation is not |
857 |
* able to resolve dchildren for given node type |
858 |
* @return true if node is leaf |
859 |
*/ |
860 |
public boolean isLeaf (Object node) throws UnknownTypeException { |
861 |
TreeModel model = (TreeModel) classNameToModel.get ( |
862 |
node.getClass ().getName () |
863 |
); |
864 |
if (model != null) |
865 |
try { |
866 |
return model.isLeaf (node); |
867 |
} catch (UnknownTypeException e) { |
868 |
} |
869 |
int i, k = models.length; |
870 |
for (i = 0; i < k; i++) { |
871 |
try { |
872 |
boolean result = models [i].isLeaf (node); |
873 |
classNameToModel.put (node.getClass ().getName (), models [i]); |
874 |
return result; |
875 |
} catch (UnknownTypeException e) { |
876 |
} |
877 |
} |
878 |
throw new UnknownTypeException (node); |
879 |
} |
880 |
|
881 |
/** |
882 |
* Registers given listener. |
883 |
* |
884 |
* @param l the listener to add |
885 |
*/ |
886 |
public void addTreeModelListener (TreeModelListener l) { |
887 |
int i, k = models.length; |
888 |
for (i = 0; i < k; i++) |
889 |
models [i].addTreeModelListener (l); |
890 |
} |
891 |
|
892 |
/** |
893 |
* Unregisters given listener. |
894 |
* |
895 |
* @param l the listener to remove |
896 |
*/ |
897 |
public void removeTreeModelListener (TreeModelListener l) { |
898 |
int i, k = models.length; |
899 |
for (i = 0; i < k; i++) |
900 |
models [i].removeTreeModelListener (l); |
901 |
} |
902 |
|
903 |
public String toString () { |
904 |
return super.toString () + "\n" + toString (" "); |
905 |
} |
906 |
|
907 |
public String toString (String n) { |
908 |
int i, k = models.length - 1; |
909 |
if (k == -1) return ""; |
910 |
StringBuffer sb = new StringBuffer (); |
911 |
for (i = 0; i < k; i++) { |
912 |
sb.append (n); |
913 |
sb.append (models [i]); |
914 |
sb.append ('\n'); |
915 |
} |
916 |
sb.append (n); |
917 |
sb.append (models [i]); |
918 |
return new String (sb); |
919 |
} |
920 |
} |
812 |
|
921 |
|
813 |
/** |
922 |
/** |
814 |
* Creates {@link org.netbeans.spi.viewmodel.NodeActionsProvider} |
923 |
* Creates {@link org.netbeans.spi.viewmodel.NodeActionsProvider} |
Lines 1086-1105
Link Here
|
1086 |
} |
1195 |
} |
1087 |
|
1196 |
|
1088 |
/** |
1197 |
/** |
1089 |
* Creates one {@link org.netbeans.spi.viewmodel.NodeModel} |
1198 |
* Creates one {@link org.netbeans.spi.viewmodel.TableModel} |
1090 |
* from given list of NodeModels. DelegatingNodeModel asks all underlaying |
1199 |
* from given list of TableModels. DelegatingTableModel asks all underlaying |
1091 |
* models for each concrete parameter, and returns first returned value. |
1200 |
* models for each concrete parameter, and returns first returned value. |
1092 |
* |
1201 |
* |
1093 |
* @author Jan Jancura |
1202 |
* @author Jan Jancura |
1094 |
*/ |
1203 |
*/ |
1095 |
static final class DelegatingNodeModel implements NodeModel { |
1204 |
final static class DelegatingTreeExpansionModel |
|
|
1205 |
implements TreeExpansionModel { |
1096 |
|
1206 |
|
1097 |
private NodeModel[] models; |
1207 |
private TreeExpansionModel[] models; |
1098 |
private HashMap classNameToModel = new HashMap (); |
1208 |
private HashMap classNameToModel = new HashMap (); |
1099 |
|
1209 |
|
1100 |
|
1210 |
|
1101 |
/** |
1211 |
/** |
1102 |
* Creates new instance of DelegatingNodeModel for given list of |
1212 |
* Creates new instance of DelegatingTableModel for given list of |
|
|
1213 |
* TableModels. |
1214 |
* |
1215 |
* @param models a list of TableModels |
1216 |
*/ |
1217 |
DelegatingTreeExpansionModel (List models) { |
1218 |
this (convert (models)); |
1219 |
} |
1220 |
|
1221 |
private static TreeExpansionModel[] convert (List l) { |
1222 |
TreeExpansionModel[] models = new TreeExpansionModel [l.size ()]; |
1223 |
return (TreeExpansionModel[]) l.toArray (models); |
1224 |
} |
1225 |
|
1226 |
/** |
1227 |
* Creates new instance of DelegatingTableModel for given array of |
1228 |
* TableModels. |
1229 |
* |
1230 |
* @param models a array of TableModels |
1231 |
*/ |
1232 |
DelegatingTreeExpansionModel (TreeExpansionModel[] models) { |
1233 |
this.models = models; |
1234 |
} |
1235 |
|
1236 |
/** |
1237 |
* Defines default state (collapsed, expanded) of given node. |
1238 |
* |
1239 |
* @param node a node |
1240 |
* @return default state (collapsed, expanded) of given node |
1241 |
*/ |
1242 |
public boolean isExpanded (Object node) |
1243 |
throws UnknownTypeException { |
1244 |
TreeExpansionModel model = (TreeExpansionModel) |
1245 |
classNameToModel.get ( |
1246 |
node.getClass ().getName () |
1247 |
); |
1248 |
if (model != null) |
1249 |
try { |
1250 |
return model.isExpanded (node); |
1251 |
} catch (UnknownTypeException e) { |
1252 |
} |
1253 |
int i, k = models.length; |
1254 |
for (i = 0; i < k; i++) { |
1255 |
try { |
1256 |
boolean result = models [i].isExpanded (node); |
1257 |
classNameToModel.put (node.getClass ().getName (), models [i]); |
1258 |
return result; |
1259 |
} catch (UnknownTypeException e) { |
1260 |
} |
1261 |
} |
1262 |
throw new UnknownTypeException (node); |
1263 |
} |
1264 |
|
1265 |
|
1266 |
/** |
1267 |
* Called when given node is expanded. |
1268 |
* |
1269 |
* @param node a expanded node |
1270 |
*/ |
1271 |
public void nodeExpanded (Object node) { |
1272 |
int i, k = models.length; |
1273 |
for (i = 0; i < k; i++) { |
1274 |
models [i].nodeExpanded (node); |
1275 |
} |
1276 |
} |
1277 |
|
1278 |
/** |
1279 |
* Called when given node is collapsed. |
1280 |
* |
1281 |
* @param node a collapsed node |
1282 |
*/ |
1283 |
public void nodeCollapsed (Object node) { |
1284 |
int i, k = models.length; |
1285 |
for (i = 0; i < k; i++) { |
1286 |
models [i].nodeCollapsed (node); |
1287 |
} |
1288 |
} |
1289 |
|
1290 |
public String toString () { |
1291 |
return super.toString () + "\n" + toString (" "); |
1292 |
} |
1293 |
|
1294 |
public String toString (String n) { |
1295 |
int i, k = models.length - 1; |
1296 |
if (k == -1) return ""; |
1297 |
StringBuffer sb = new StringBuffer (); |
1298 |
for (i = 0; i < k; i++) { |
1299 |
sb.append (n); |
1300 |
sb.append (models [i]); |
1301 |
sb.append ('\n'); |
1302 |
} |
1303 |
sb.append (n); |
1304 |
sb.append (models [i]); |
1305 |
return new String (sb); |
1306 |
} |
1307 |
} |
1308 |
|
1309 |
/** |
1310 |
* Creates one {@link org.netbeans.spi.viewmodel.NodeModel} |
1311 |
* from given list of NodeModels. DelegatingNodeModel asks all underlaying |
1312 |
* models for each concrete parameter, and returns first returned value. |
1313 |
* |
1314 |
* @author Jan Jancura |
1315 |
*/ |
1316 |
static final class DelegatingNodeModel implements NodeModel { |
1317 |
|
1318 |
private NodeModel[] models; |
1319 |
private HashMap classNameToModel = new HashMap (); |
1320 |
|
1321 |
|
1322 |
/** |
1323 |
* Creates new instance of DelegatingNodeModel for given list of |
1103 |
* NodeModels. |
1324 |
* NodeModels. |
1104 |
* |
1325 |
* |
1105 |
* @param models a list of NodeModels |
1326 |
* @param models a list of NodeModels |
Lines 1662-1667
Link Here
|
1662 |
int i, k = models.length; |
1883 |
int i, k = models.length; |
1663 |
for (i = 0; i < k; i++) |
1884 |
for (i = 0; i < k; i++) |
1664 |
models [i].removeTreeModelListener (l); |
1885 |
models [i].removeTreeModelListener (l); |
|
|
1886 |
} |
1887 |
} |
1888 |
|
1889 |
/** |
1890 |
* Implements set of tree view features. |
1891 |
*/ |
1892 |
public static class TreeFeatures { |
1893 |
|
1894 |
private JComponent view; |
1895 |
|
1896 |
private TreeFeatures (JComponent view) { |
1897 |
this.view = view; |
1898 |
} |
1899 |
|
1900 |
/** |
1901 |
* Returns <code>true</code> if given node is expanded in given view. |
1902 |
* |
1903 |
* @param view a view created by this Models class |
1904 |
* @param node a node to be checked |
1905 |
* @return <code>true</code> if given node is expanded in given view |
1906 |
*/ |
1907 |
public boolean isExpanded ( |
1908 |
Object node |
1909 |
) { |
1910 |
return ((TreeTable) view).isExpanded (node); |
1911 |
} |
1912 |
|
1913 |
/** |
1914 |
* Expands given list of nodes in given view. |
1915 |
* |
1916 |
* @param view a view created by this Models class |
1917 |
* @param node a list of nodes to be expanded |
1918 |
*/ |
1919 |
public void expandNode ( |
1920 |
Object node |
1921 |
) { |
1922 |
((TreeTable) view).expandNode (node); |
1923 |
} |
1924 |
|
1925 |
/** |
1926 |
* Collapses given node in given view. |
1927 |
* |
1928 |
* @param view a view created by this Models class |
1929 |
* @param node a node to be expanded |
1930 |
*/ |
1931 |
public void collapseNode ( |
1932 |
Object node |
1933 |
) { |
1934 |
((TreeTable) view).collapseNode (node); |
1935 |
} |
1936 |
} |
1937 |
|
1938 |
/** |
1939 |
* Default implemetation of {@link CompoundModel}. It delegates all |
1940 |
* functionality to given instanceo of |
1941 |
* {@link org.netbeans.spi.viewmodel.TreeModel}, |
1942 |
* {@link org.netbeans.spi.viewmodel.NodeModel} and |
1943 |
* {@link org.netbeans.spi.viewmodel.NodeActionsProvider}. |
1944 |
* |
1945 |
* @author Jan Jancura |
1946 |
*/ |
1947 |
public static final class CompoundModel implements TreeModel, |
1948 |
NodeModel, NodeActionsProvider, TableModel, TreeExpansionModel { |
1949 |
|
1950 |
private TreeModel treeModel; |
1951 |
private NodeModel nodeModel; |
1952 |
private NodeActionsProvider nodeActionsProvider; |
1953 |
private ColumnModel[] columnModels; |
1954 |
private TableModel tableModel; |
1955 |
private TreeExpansionModel treeExpansionModel; |
1956 |
|
1957 |
|
1958 |
// init .................................................................... |
1959 |
|
1960 |
/** |
1961 |
* Creates a new instance of {@link CompoundModel} for given models. |
1962 |
* |
1963 |
* @param treeModel a tree model to delegate on |
1964 |
* @param nodeModel a node model to delegate on |
1965 |
* @param nodeActionsProvider a node actions provider to delegate on |
1966 |
* @param nodeActionsProvider a columns modeol to delegate on |
1967 |
*/ |
1968 |
public CompoundModel ( |
1969 |
TreeModel treeModel, |
1970 |
TreeExpansionModel treeExpansionModel, |
1971 |
NodeModel nodeModel, |
1972 |
NodeActionsProvider nodeActionsProvider, |
1973 |
List columnModels, |
1974 |
TableModel tableModel |
1975 |
) { |
1976 |
if (treeModel == null) throw new NullPointerException (); |
1977 |
if (treeModel == null) throw new NullPointerException (); |
1978 |
if (nodeModel == null) throw new NullPointerException (); |
1979 |
if (tableModel == null) throw new NullPointerException (); |
1980 |
if (nodeActionsProvider == null) throw new NullPointerException (); |
1981 |
|
1982 |
this.treeModel = treeModel; |
1983 |
this.treeExpansionModel = treeExpansionModel; |
1984 |
this.nodeModel = nodeModel; |
1985 |
this.tableModel = tableModel; |
1986 |
this.nodeActionsProvider = nodeActionsProvider; |
1987 |
this.columnModels = (ColumnModel[]) columnModels.toArray ( |
1988 |
new ColumnModel [columnModels.size ()] |
1989 |
); |
1990 |
} |
1991 |
|
1992 |
|
1993 |
// TreeModel ............................................................... |
1994 |
|
1995 |
/** |
1996 |
* Returns the root node of the tree or null, if the tree is empty. |
1997 |
* |
1998 |
* @return the root node of the tree or null |
1999 |
*/ |
2000 |
public Object getRoot () { |
2001 |
return treeModel.getRoot (); |
2002 |
} |
2003 |
|
2004 |
/** |
2005 |
* Returns children for given parent on given indexes. |
2006 |
* |
2007 |
* @param parent a parent of returned nodes |
2008 |
* @throws UnknownTypeException if this TreeModel implementation is not |
2009 |
* able to resolve dchildren for given node type |
2010 |
* |
2011 |
* @return children for given parent on given indexes |
2012 |
*/ |
2013 |
public Object[] getChildren (Object parent, int from, int to) |
2014 |
throws UnknownTypeException { |
2015 |
return treeModel.getChildren (parent, from, to); |
2016 |
} |
2017 |
|
2018 |
/** |
2019 |
* Returns number of children for given node. |
2020 |
* |
2021 |
* @param node the parent node |
2022 |
* @throws UnknownTypeException if this TreeModel implementation is not |
2023 |
* able to resolve children for given node type |
2024 |
* |
2025 |
* @return true if node is leaf |
2026 |
*/ |
2027 |
public int getChildrenCount (Object node) throws UnknownTypeException { |
2028 |
return treeModel.getChildrenCount (node); |
2029 |
} |
2030 |
|
2031 |
/** |
2032 |
* Returns true if node is leaf. |
2033 |
* |
2034 |
* @throws UnknownTypeException if this TreeModel implementation is not |
2035 |
* able to resolve dchildren for given node type |
2036 |
* @return true if node is leaf |
2037 |
*/ |
2038 |
public boolean isLeaf (Object node) throws UnknownTypeException { |
2039 |
return treeModel.isLeaf (node); |
2040 |
} |
2041 |
|
2042 |
|
2043 |
// NodeModel ............................................................... |
2044 |
|
2045 |
/** |
2046 |
* Returns display name for given node. |
2047 |
* |
2048 |
* @throws UnknownTypeException if this NodeModel implementation is not |
2049 |
* able to resolve display name for given node type |
2050 |
* @return display name for given node |
2051 |
*/ |
2052 |
public String getDisplayName (Object node) throws UnknownTypeException { |
2053 |
return nodeModel.getDisplayName (node); |
2054 |
} |
2055 |
|
2056 |
/** |
2057 |
* Returns tooltip for given node. |
2058 |
* |
2059 |
* @throws UnknownTypeException if this NodeModel implementation is not |
2060 |
* able to resolve tooltip for given node type |
2061 |
* @return tooltip for given node |
2062 |
*/ |
2063 |
public String getShortDescription (Object node) |
2064 |
throws UnknownTypeException { |
2065 |
return nodeModel.getShortDescription (node); |
2066 |
} |
2067 |
|
2068 |
/** |
2069 |
* Returns icon for given node. |
2070 |
* |
2071 |
* @throws ComputingException if the icon resolving process |
2072 |
* is time consuming, and the value will be updated later |
2073 |
* @throws UnknownTypeException if this NodeModel implementation is not |
2074 |
* able to resolve icon for given node type |
2075 |
* @return icon for given node |
2076 |
*/ |
2077 |
public String getIconBase (Object node) |
2078 |
throws UnknownTypeException { |
2079 |
return nodeModel.getIconBase (node); |
2080 |
} |
2081 |
|
2082 |
|
2083 |
// NodeActionsProvider ..................................................... |
2084 |
|
2085 |
/** |
2086 |
* Performs default action for given node. |
2087 |
* |
2088 |
* @throws UnknownTypeException if this NodeActionsProvider implementation |
2089 |
* is not able to resolve actions for given node type |
2090 |
* @return display name for given node |
2091 |
*/ |
2092 |
public void performDefaultAction (Object node) throws UnknownTypeException { |
2093 |
nodeActionsProvider.performDefaultAction (node); |
2094 |
} |
2095 |
|
2096 |
/** |
2097 |
* Returns set of actions for given node. |
2098 |
* |
2099 |
* @throws UnknownTypeException if this NodeActionsProvider implementation |
2100 |
* is not able to resolve actions for given node type |
2101 |
* @return display name for given node |
2102 |
*/ |
2103 |
public Action[] getActions (Object node) throws UnknownTypeException { |
2104 |
return nodeActionsProvider.getActions (node); |
2105 |
} |
2106 |
|
2107 |
|
2108 |
// ColumnsModel ............................................................ |
2109 |
|
2110 |
/** |
2111 |
* Returns sorted array of |
2112 |
* {@link org.netbeans.spi.viewmodel.ColumnModel}s. |
2113 |
* |
2114 |
* @return sorted array of ColumnModels |
2115 |
*/ |
2116 |
public ColumnModel[] getColumns () { |
2117 |
return columnModels; |
2118 |
} |
2119 |
|
2120 |
|
2121 |
// TableModel .............................................................. |
2122 |
|
2123 |
public Object getValueAt (Object node, String columnID) throws |
2124 |
UnknownTypeException { |
2125 |
return tableModel.getValueAt (node, columnID); |
2126 |
} |
2127 |
|
2128 |
public boolean isReadOnly (Object node, String columnID) throws |
2129 |
UnknownTypeException { |
2130 |
return tableModel.isReadOnly (node, columnID); |
2131 |
} |
2132 |
|
2133 |
public void setValueAt (Object node, String columnID, Object value) throws |
2134 |
UnknownTypeException { |
2135 |
tableModel.setValueAt (node, columnID, value); |
2136 |
} |
2137 |
|
2138 |
|
2139 |
// TreeExpansionModel ...................................................... |
2140 |
|
2141 |
/** |
2142 |
* Defines default state (collapsed, expanded) of given node. |
2143 |
* |
2144 |
* @param node a node |
2145 |
* @return default state (collapsed, expanded) of given node |
2146 |
*/ |
2147 |
public boolean isExpanded (Object node) throws UnknownTypeException { |
2148 |
if (treeExpansionModel == null) return false; |
2149 |
return treeExpansionModel.isExpanded (node); |
2150 |
} |
2151 |
|
2152 |
/** |
2153 |
* Called when given node is expanded. |
2154 |
* |
2155 |
* @param node a expanded node |
2156 |
*/ |
2157 |
public void nodeExpanded (Object node) { |
2158 |
if (treeExpansionModel != null) |
2159 |
treeExpansionModel.nodeExpanded (node); |
2160 |
} |
2161 |
|
2162 |
/** |
2163 |
* Called when given node is collapsed. |
2164 |
* |
2165 |
* @param node a collapsed node |
2166 |
*/ |
2167 |
public void nodeCollapsed (Object node) { |
2168 |
if (treeExpansionModel != null) |
2169 |
treeExpansionModel.nodeCollapsed (node); |
2170 |
} |
2171 |
|
2172 |
|
2173 |
// listeners ............................................................... |
2174 |
|
2175 |
/** |
2176 |
* Registers given listener. |
2177 |
* |
2178 |
* @param l the listener to add |
2179 |
*/ |
2180 |
public void addTreeModelListener (TreeModelListener l) { |
2181 |
treeModel.addTreeModelListener (l); |
2182 |
nodeModel.addTreeModelListener (l); |
2183 |
nodeActionsProvider.addTreeModelListener (l); |
2184 |
tableModel.addTreeModelListener (l); |
2185 |
} |
2186 |
|
2187 |
/** |
2188 |
* Unregisters given listener. |
2189 |
* |
2190 |
* @param l the listener to remove |
2191 |
*/ |
2192 |
public void removeTreeModelListener (TreeModelListener l) { |
2193 |
treeModel.removeTreeModelListener (l); |
2194 |
nodeModel.removeTreeModelListener (l); |
2195 |
nodeActionsProvider.removeTreeModelListener (l); |
2196 |
tableModel.removeTreeModelListener (l); |
2197 |
} |
2198 |
|
2199 |
public String toString () { |
2200 |
return super.toString () + |
2201 |
"\n TreeModel = " + treeModel + |
2202 |
"\n NodeModel = " + nodeModel + |
2203 |
"\n TableModel = " + tableModel + |
2204 |
"\n NodeActionsProvider = " + nodeActionsProvider + |
2205 |
"\n ColumnsModel = " + columnModels; |
1665 |
} |
2206 |
} |
1666 |
} |
2207 |
} |
1667 |
} |
2208 |
} |