KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > xml > wsdl > ui > wsdl > nodes > ImportViewNodes


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20
21 package org.netbeans.modules.xml.wsdl.ui.wsdl.nodes;
22
23 import java.awt.Image JavaDoc;
24 import java.beans.PropertyChangeEvent JavaDoc;
25 import java.beans.PropertyChangeListener JavaDoc;
26 import java.io.Serializable JavaDoc;
27 import java.text.MessageFormat JavaDoc;
28 import java.util.ArrayList JavaDoc;
29 import java.util.Arrays JavaDoc;
30 import java.util.Collection JavaDoc;
31 import java.util.Collections JavaDoc;
32 import java.util.Comparator JavaDoc;
33
34 import javax.swing.Action JavaDoc;
35 import javax.swing.ImageIcon JavaDoc;
36
37 import org.netbeans.api.project.FileOwnerQuery;
38 import org.netbeans.api.project.Project;
39 import org.netbeans.api.project.ProjectInformation;
40 import org.netbeans.api.project.ProjectUtils;
41 import org.netbeans.api.project.SourceGroup;
42 import org.netbeans.api.queries.VisibilityQuery;
43 import org.openide.filesystems.FileObject;
44 import org.openide.filesystems.FileUtil;
45 import org.openide.loaders.DataFolder;
46 import org.openide.nodes.Children;
47 import org.openide.nodes.CookieSet;
48 import org.openide.nodes.FilterNode;
49 import org.openide.nodes.Node;
50 import org.openide.util.Lookup;
51 import org.openide.util.NbBundle;
52 import org.openide.util.Utilities;
53 import org.openide.util.WeakListeners;
54 import org.openide.util.lookup.ProxyLookup;
55
56
57
58 /**
59  * Support for creating logical views.
60  * @author Jesse Glick, Petr Hrebejk
61  */

62 public class ImportViewNodes {
63     
64     private static Image JavaDoc badgedImage = loadImage("org/netbeans/modules/xml/wsdl/ui/nodes/resources/error-badge.gif");
65     
66     
67     static final class GroupNode extends FilterNode implements PropertyChangeListener JavaDoc {
68
69         
70          final String JavaDoc GROUP_NAME_PATTERN = NbBundle.getMessage(
71             ImportViewNodes.class, "FMT_ImportViewNodes_GroupName" ); // NOI18N
72

73         private Project project;
74         private ProjectInformation pi;
75         private SourceGroup group;
76         
77         public GroupNode(Project mainProject,
78                          Project srcGroupProject,
79                          SourceGroup group,
80                          SourceGroup[] allGroups,
81                          DataFolder dataFolder,
82                          FileObject fileToExclude) {
83             super( dataFolder.getNodeDelegate(),
84                    new SourceGroupsChildren(dataFolder.getPrimaryFile(),
85                                                group,
86                                                allGroups,
87                                                mainProject,
88                                                fileToExclude),
89                    createLookup(srcGroupProject, group, dataFolder) );
90
91             this.project = srcGroupProject;
92             this.pi = ProjectUtils.getInformation( project );
93             this.group = group;
94             pi.addPropertyChangeListener(WeakListeners.propertyChange(this, pi));
95             group.addPropertyChangeListener( WeakListeners.propertyChange( this, group ) );
96         }
97
98         // XXX May need to change icons as well
99

100         public String JavaDoc getName() {
101                 return group.getName();
102             
103         }
104
105         public String JavaDoc getDisplayName() {
106                 return MessageFormat.format( GROUP_NAME_PATTERN,
107                     new Object JavaDoc[] { group.getDisplayName(), pi.getDisplayName(), getOriginal().getDisplayName() } );
108             
109         }
110
111         public String JavaDoc getShortDescription() {
112             FileObject gdir = group.getRootFolder();
113             String JavaDoc dir = FileUtil.getFileDisplayName(gdir);
114             return NbBundle.getMessage(ImportViewNodes.class,
115                                        "HINT_group", // NOI18N
116
dir);
117         }
118
119         public boolean canRename() {
120             return false;
121         }
122
123         public boolean canCut() {
124             return false;
125         }
126
127         public boolean canCopy() {
128             // At least for now.
129
return false;
130         }
131
132         public boolean canDestroy() {
133             return false;
134         }
135
136         public Action JavaDoc[] getActions( boolean context ) {
137
138             if ( context ) {
139                 return super.getActions( true );
140             }
141             else {
142                 Action JavaDoc[] folderActions = super.getActions( false );
143                 return folderActions;
144             }
145         }
146
147         // Private methods -------------------------------------------------
148

149         public void propertyChange(PropertyChangeEvent JavaDoc evt) {
150             String JavaDoc prop = evt.getPropertyName();
151             if (ProjectInformation.PROP_DISPLAY_NAME.equals(prop)) {
152                 fireDisplayNameChange(null, null);
153             } else if (ProjectInformation.PROP_NAME.equals(prop)) {
154                 fireNameChange(null, null);
155             } else if (ProjectInformation.PROP_ICON.equals(prop)) {
156                 // OK, ignore
157
} else if ( "name".equals(prop) ) { // NOI18N
158
fireNameChange(null, null);
159             } else if ( "displayName".equals(prop) ) { // NOI18N
160
fireDisplayNameChange(null, null);
161             } else if ( "icon".equals(prop) ) { // NOI18N
162
// OK, ignore
163
} else if ( "rootFolder".equals(prop) ) { // NOI18N
164
// XXX Do something to children and lookup
165
fireNameChange(null, null);
166                 fireDisplayNameChange(null, null);
167                 fireShortDescriptionChange(null, null);
168             } else {
169                 //TODO:SKINI assert false : "Attempt to fire an unsupported property change event from " + pi.getClass().getName() + ": " + prop;
170
}
171         }
172         
173         private static Lookup createLookup( Project p, SourceGroup group, DataFolder dataFolder ) {
174             return new ProxyLookup(new Lookup[] {
175                 dataFolder.getNodeDelegate().getLookup(),
176                 p.getLookup(),
177             });
178         }
179     }
180     
181     public static final class SourceGroups extends Children.Keys {
182         private FileObject mFileToExclude;
183         
184         private Project ownerProject;
185         
186         private SourceGroup[] allGroups;
187         
188         public SourceGroups( Project owner,
189                  SourceGroup[] ownerProjectGroups,
190                  SourceGroup[] depedentProjectGroups,
191                  FileObject fileToExclude) {
192                 ownerProject = owner;
193                 allGroups = new SourceGroup[ownerProjectGroups.length + depedentProjectGroups.length];
194                 System.arraycopy(ownerProjectGroups, 0, allGroups, 0, ownerProjectGroups.length);
195                 System.arraycopy(depedentProjectGroups, 0, allGroups, ownerProjectGroups.length, depedentProjectGroups.length);
196                 this.mFileToExclude = fileToExclude;
197         }
198         
199         protected void addNotify() {
200             super.addNotify();
201             setKeys( getKeys() );
202         }
203
204         protected void removeNotify() {
205             setKeys( Collections.EMPTY_SET );
206             super.removeNotify();
207         }
208         
209         
210         protected Node[] createNodes(Object JavaDoc key) {
211             FileObject folder = null;
212             SourceGroup group = null;
213             
214             if ( key instanceof SourceGroup ) {
215                 group = (SourceGroup)key;
216                 folder = group.getRootFolder();
217                 Project project = FileOwnerQuery.getOwner(folder);
218                 DataFolder dFolder = DataFolder.findFolder( folder );
219                 
220                 GroupNode gNode = new GroupNode( ownerProject,
221                                                  project,
222                                                  group,
223                                                  this.allGroups,
224                                                  DataFolder.findFolder( folder ),
225                                                  this.mFileToExclude);
226                 return new Node[] { gNode };
227             } else {
228                 return new Node[0];
229             }
230         }
231         
232         private Collection JavaDoc getKeys() {
233                 return Arrays.asList( allGroups );
234         }
235     }
236     
237     public static final class SourceGroupsChildren extends Children.Keys {
238         
239         private Project ownerProject;
240         
241         private SourceGroup[] allGroups;
242         
243         private SourceGroup ownerGroup;
244         
245         //root folder of source group or any other sub folder
246
private FileObject fo;
247         
248         private FileObject mFileToExclude;
249         
250         public SourceGroupsChildren( FileObject folder ,
251                                     SourceGroup owner,
252                                     SourceGroup[] groups,
253                                     Project project,
254                                     FileObject fileToExclude) {
255             this.fo = folder;
256             this.ownerGroup = owner;
257             this.allGroups = groups;
258             this.ownerProject = project;
259             this.mFileToExclude = fileToExclude;
260         }
261         
262         protected void addNotify() {
263             super.addNotify();
264             setKeys( getKeys() );
265         }
266
267         protected void removeNotify() {
268             setKeys( Collections.EMPTY_SET );
269             super.removeNotify();
270         }
271         
272         
273         protected Node[] createNodes(Object JavaDoc key) {
274
275             FileObject folder = null;
276             
277             if ( key instanceof Key ) {
278                 folder = ((Key)key).folder;
279                 Node delegate = null;
280                 //if folder which is a sub folder in a source group.
281
if(folder.isFolder()) {
282                     delegate = DataFolder.findFolder( folder ).getNodeDelegate();
283                     if(delegate != null) {
284                         FilterNode fn = new FilterNode(
285                             delegate,
286                             new SourceGroupsChildren( folder,
287                                                       this.ownerGroup,
288                                                       this.allGroups,
289                                                       this.ownerProject,
290                                                       this.mFileToExclude) );
291                         return new Node[] { fn };
292                     } else {
293                         return new Node[0];
294                     }
295                     
296                 } else {
297                     //file
298
try {
299                         delegate = DataFolder.find(folder).getNodeDelegate();
300                         
301                         if(delegate != null) {
302                             Project prj = FileOwnerQuery.getOwner(folder);
303                             if(ownerProject.equals(prj)) {
304                                 FilterNode fn = new FilterNode(delegate) {
305                                      public Action JavaDoc getPreferredAction() {
306                                          return null;
307                                      }
308                                     };
309                                     return new Node[] { fn };
310                             } else {
311                                 FilterNode fn = new DepedentProjectFileNode(delegate, folder, this.ownerGroup, allGroups);
312                                 return new Node[] { fn };
313                             }
314                         }
315                         
316                     } catch(Exception JavaDoc ex) {
317                         ex.printStackTrace();
318                     }
319                     
320                     return new Node[0];
321                 }
322                 
323             }
324             else {
325                 return new Node[0];
326             }
327         }
328
329         private Collection JavaDoc getKeys() {
330             FileObject files[] = fo.getChildren();
331             ArrayList JavaDoc children = new ArrayList JavaDoc( files.length );
332
333             for( int i = 0; i < files.length; i++ ) {
334                 //we have a file we want to allow olny wsdls and xsds
335
if (!files[i].isFolder()) {
336                      if(!files[i].equals(mFileToExclude)
337                          && VisibilityQuery.getDefault().isVisible( files[i] )
338                         && isAcceptableFile(files[i])) {
339                         children.add( new Key( files[i]) );
340                      }
341                 } else {
342                     //we have a folder
343
children.add( new Key( files[i] ) );
344                 }
345             }
346             
347             //sort files
348
Collections.sort(children, new KeyComparator());
349             
350             return children;
351         }
352         
353         private class Key {
354
355             private FileObject folder;
356
357             private Key ( FileObject folder) {
358                 this.folder = folder;
359             }
360             
361             FileObject getFileObject() {
362                 return folder;
363             }
364
365         }
366
367         private class KeyComparator implements Comparator JavaDoc, Serializable JavaDoc{
368             
369             public int compare(Object JavaDoc arg0, Object JavaDoc arg1) {
370                 FileObject file0 = ((Key) arg0).getFileObject();
371                 FileObject file1 = ((Key) arg1).getFileObject();
372                 return file0.getNameExt().compareToIgnoreCase(file1.getNameExt());
373                 
374             }
375         }
376     }
377     
378     private static boolean isAcceptableFile(FileObject fo) {
379             if(fo.getExt().equalsIgnoreCase("wsdl")
380                || fo.getExt().equalsIgnoreCase("xsd")) {
381                     return true;
382             }
383             
384             return false;
385     }
386         
387         
388     static final class DepedentProjectFileNode extends FilterNode {
389         
390         private FileObject fileObject;
391         private SourceGroup ownerGroup;
392         private SourceGroup[] allGroups;
393         private boolean fileExists;
394         private ProxyLookup lookup;
395         private CookieSet set;
396         private DuplicateFileCookie dupCookie;
397         
398         public DepedentProjectFileNode(Node original, FileObject fileObj, SourceGroup owner,SourceGroup[] groups ) {
399             super(original);
400             this.fileObject = fileObj;
401             this.ownerGroup = owner;
402             this.allGroups = groups;
403             this.set = new CookieSet();
404             this.dupCookie = new DuplicateFileCookie(fileObject);
405         }
406         
407         public Image JavaDoc getIcon(int type) {
408             Image JavaDoc img = super.getIcon(type);
409             fileExists = isFileExistsInPreviousProject();
410             if(fileExists) {
411                 this.set.add(dupCookie);
412                 return Utilities.mergeImages(img, badgedImage, 10, 10);
413             } else {
414                 this.set.remove(dupCookie);
415             }
416             return img;
417         }
418         
419         
420         public Cookie getCookie(Class JavaDoc type) {
421             Cookie c = this.set.getCookie(type);
422             if(c != null) {
423                 return c;
424             }
425             
426             return super.getCookie(type);
427         }
428         
429         public String JavaDoc getShortDescription() {
430             if(isFileExistsInPreviousProject()) {
431                 return "File already exists in a previous project.";
432             }
433             
434             return super.getShortDescription();
435         }
436         
437         private boolean isFileExistsInPreviousProject() {
438             boolean result = false;
439             for(int i = 0 ; i < allGroups.length; i++) {
440                 SourceGroup group = allGroups[i];
441                 //we need to check all previous source group till the
442
//owner source group where this depdent project file is stored.
443
if(group.equals(ownerGroup)) {
444                     break;
445                 }
446                 result = isFileExistInRootFolder(group.getRootFolder());
447                 if(result) {
448                     //set the preceding owner project
449
dupCookie.setPrecedingOwnerProject(FileOwnerQuery.getOwner(group.getRootFolder()));
450                     break;
451                 }
452             }
453             
454             
455             return result;
456         }
457         
458         boolean isFileExistInRootFolder(FileObject rootFolder) {
459             boolean result = false;
460             FileObject[] children = rootFolder.getChildren();
461             for(int i = 0; i < children.length; i++) {
462                 FileObject file = children[i];
463                 if(file.isFolder()) {
464                     result = isFileExistInRootFolder(file);
465                     if(result) {
466                         break;
467                     }
468                 } else {
469                     if(isAcceptableFile(file)) {
470                         result = isSameFileName(file);
471                         if(result) {
472                             break;
473                         }
474                     }
475                 }
476             }
477             return result;
478         }
479         
480         boolean isSameFileName(FileObject file) {
481             boolean result = false;
482             result = file.getNameExt().equals(fileObject.getNameExt());
483             return result;
484         }
485     }
486     
487     /**
488     * Marker cookie to indicate that node represents a duplicate file.
489     */

490     
491     public static final class DuplicateFileCookie implements Node.Cookie {
492         private FileObject fileObject;
493         private Project ownerProject;
494         
495         public DuplicateFileCookie(FileObject file) {
496             this.fileObject = file;
497         }
498         
499         public void setPrecedingOwnerProject(Project project) {
500             this.ownerProject = project;
501         }
502         
503         public Project getPrecedingOwnerProject() {
504             return this.ownerProject;
505         }
506         
507         public String JavaDoc getFileName() {
508             return fileObject.getNameExt();
509         }
510     }
511     
512     /** Loads the <code>Image</code> object from the relative file path.
513      * @param path Image relative file path.
514      * @return Corresponding <code>Image</code> object.
515      */

516     private static Image JavaDoc loadImage(String JavaDoc path) {
517         return (new ImageIcon JavaDoc(ImportViewNodes.class.getClassLoader().getResource(path))).getImage();
518     }
519 }
520
Popular Tags