|
1
19
20 package org.netbeans.modules.palette;
21
22 import java.awt.event.ActionEvent  ;
23 import java.beans.PropertyChangeEvent ;
24 import java.beans.PropertyChangeSupport ;
25 import java.util.ArrayList ;
26 import javax.swing.Action ;
27 import org.netbeans.spi.palette.DragAndDropHandler;
28 import org.netbeans.spi.palette.PaletteController;
29 import org.openide.nodes.*;
30 import org.openide.util.*;
31 import org.netbeans.modules.palette.ui.Customizer;
32 import org.netbeans.spi.palette.PaletteActions;
33
34
39 public class DefaultModel implements Model, NodeListener {
40
41
44 private RootNode rootNode;
45
46
49 private Item selectedItem;
50
53 private Category selectedCategory;
54 private PropertyChangeSupport propertySupport;
55 private ArrayList <ModelListener> modelListeners = new ArrayList <ModelListener>( 3 );
56
59 private Category[] categories;
60
61
66 public DefaultModel( RootNode rootNode ) {
67 this.rootNode = rootNode;
68
69 propertySupport = new PropertyChangeSupport ( this );
70 this.rootNode.addNodeListener( this );
71 }
72
73 public void setSelectedItem( Lookup category, Lookup item ) {
74 Category cat = null;
75 Item it = null;
76 if( null != category ) {
77 Node catNode = (Node)category.lookup( Node.class );
78 if( null != catNode ) {
79 cat = findCategory( catNode );
80 }
81 }
82 if( null != item && null != cat ) {
83 Node itNode = (Node)item.lookup( Node.class );
84 if( null != itNode ) {
85 it = findItem( cat, itNode ); }
87 }
88
89 Item oldValue = selectedItem;
90 this.selectedItem = it;
91 this.selectedCategory = cat;
92 propertySupport.firePropertyChange( Model.PROP_SELECTED_ITEM, oldValue, selectedItem );
93 }
94
95 public void clearSelection() {
96 setSelectedItem( null, null );
97 }
98 public Action [] getActions() {
99 return rootNode.getActions( false );
100 }
101
102 public Item getSelectedItem() {
103 return selectedItem;
104 }
105
106 public Category getSelectedCategory() {
107 return selectedCategory;
108 }
109
110 public void addModelListener( ModelListener listener ) {
111 synchronized( modelListeners ) {
112 modelListeners.add( listener );
113 propertySupport.addPropertyChangeListener( listener );
114 }
115 }
116
117 public void removeModelListener( ModelListener listener ) {
118 synchronized( modelListeners ) {
119 modelListeners.remove( listener );
120 propertySupport.removePropertyChangeListener( listener );
121 }
122 }
123
124
125 public Category[] getCategories() {
126 if( null == categories ) {
127 Node[] nodes = rootNode.getChildren().getNodes( canBlock() );
128 categories = nodes2categories( nodes );
129 }
130 return categories;
131 }
132
133 public static boolean canBlock() {
134 return !Children.MUTEX.isReadAccess() && !Children.MUTEX.isWriteAccess ();
135 }
136
137
140 public void childrenAdded(NodeMemberEvent ev) {
141 categories = null;
142 if( isRefreshingChildren )
143 return;
144 getCategories();
145 Category[] addedCategories = findCategories( ev.getDelta() );
146 fireCategoriesChanged( addedCategories, true );
147 }
148
149
152 public void childrenRemoved(NodeMemberEvent ev) {
153 Category[] removedCategories = findCategories( ev.getDelta() );
154 categories = null;
155 fireCategoriesChanged( removedCategories, false );
156 }
157
158
161 public void childrenReordered(NodeReorderEvent ev) {
162 categories = null;
163 fireCategoriesChanged( null, false );
164 }
165
166
169 public void nodeDestroyed(NodeEvent ev) {
170 this.rootNode.removeNodeListener( this );
171 }
172
173 public void propertyChange(PropertyChangeEvent evt) {
174 }
175
176 private void fireCategoriesChanged( Category[] changedCategories, boolean added ) {
177 ModelListener[] listeners;
178 synchronized( modelListeners ) {
179 listeners = new ModelListener[modelListeners.size()];
180 listeners = modelListeners.toArray( listeners );
181 }
182 for( int i=0; i<listeners.length; i++ ) {
183 if( null != changedCategories ) {
184 if( added ) {
185 listeners[i].categoriesAdded( changedCategories );
186 } else {
187 listeners[i].categoriesRemoved( changedCategories );
188 }
189 } else {
190 listeners[i].categoriesReordered();
191 }
192 }
193 }
194
195
198 private Category[] nodes2categories( Node[] nodes ) {
199 Category[] res = new Category[ nodes.length ];
200
201 for( int i=0; i<res.length; i++ ) {
202 res[i] = new DefaultCategory( nodes[i] );
203 }
204
205 return res;
206 }
207
208 private Category[] findCategories( Node[] nodes ) {
209 Category[] res = new Category[ nodes.length ];
210
211 for( int i=0; i<res.length; i++ ) {
212 boolean found = false;
213 for( int j=0; !found && null != categories && j<categories.length; j++ ) {
214 Node catNode = (Node)categories[j].getLookup().lookup( Node.class );
215 if( nodes[i].equals( catNode ) ) {
216 res[i] = categories[i];
217 found = true;
218 }
219 }
220 if( !found ) {
221 res[i] = new DefaultCategory( nodes[i] );
222 }
223 }
224
225 return res;
226 }
227
228 private boolean isRefreshingChildren = false;
229 public void refresh() {
230 PaletteActions customActions = (PaletteActions)rootNode.getLookup().lookup( PaletteActions.class );
231 Action customRefreshAction = customActions.getRefreshAction();
232 if( null != customRefreshAction ) {
233 customRefreshAction.actionPerformed( new ActionEvent ( getRoot(), 0, "refresh" ) ); }
235 clearSelection();
236 categories = null;
237 isRefreshingChildren = true;
238 try {
239 rootNode.refreshChildren();
240 } finally {
241 isRefreshingChildren = false;
242 }
243 fireCategoriesChanged( null, false );
244 }
245
246 public void showCustomizer( PaletteController controller, Settings settings ) {
247 Customizer.show( rootNode, controller, settings );
248 }
249
250 public Lookup getRoot() {
251 return rootNode.getLookup();
252 }
253
254 public boolean moveCategory( Category source, Category target, boolean moveBefore ) {
255 int targetIndex = categoryToIndex( target );
256 if( !moveBefore ) {
257 targetIndex++;
258 }
259 DragAndDropHandler handler = getDragAndDropHandler();
260 return handler.moveCategory( source.getLookup(), targetIndex );
261 }
262
263 private int categoryToIndex( Category category ) {
264 Node node = (Node)category.getLookup().lookup( Node.class );
265 if( null != node ) {
266 Index order = (Index)rootNode.getCookie( Index.class );
267 if( null != order ) {
268 return order.indexOf( node );
269 }
270 }
271 return -1;
272 }
273
274 public String getName() {
275 return rootNode.getName();
276 }
277
278 private Category findCategory( Node node ) {
279 Category[] cats = getCategories();
280 for( int i=0; i<cats.length; i++ ) {
281 Node catNode = (Node)cats[i].getLookup().lookup( Node.class );
282 if( null != catNode && catNode.equals( node ) )
283 return cats[i];
284 }
285 return null;
286 }
287
288 private Item findItem( Category category, Node node ) {
289 Item[] items = category.getItems();
290 for( int i=0; i<items.length; i++ ) {
291 Node itNode = (Node)items[i].getLookup().lookup( Node.class );
292 if( null != itNode && itNode.equals( node ) )
293 return items[i];
294 }
295 return null;
296 }
297
298 public boolean canReorderCategories() {
299 return getDragAndDropHandler().canReorderCategories( rootNode.getLookup() );
300 }
301
302 private DragAndDropHandler getDragAndDropHandler() {
303 return (DragAndDropHandler)rootNode.getLookup().lookup( DragAndDropHandler.class );
304 }
305 }
306
|
Popular Tags
|
Java API By Example, From Geeks To Geeks.