1 19 20 21 package org.netbeans.modules.xml.wsdl.ui.wsdl.nodes; 22 23 import java.awt.Image ; 24 import java.beans.PropertyChangeEvent ; 25 import java.beans.PropertyChangeListener ; 26 import java.io.Serializable ; 27 import java.text.MessageFormat ; 28 import java.util.ArrayList ; 29 import java.util.Arrays ; 30 import java.util.Collection ; 31 import java.util.Collections ; 32 import java.util.Comparator ; 33 34 import javax.swing.Action ; 35 import javax.swing.ImageIcon ; 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 62 public class ImportViewNodes { 63 64 private static Image badgedImage = loadImage("org/netbeans/modules/xml/wsdl/ui/nodes/resources/error-badge.gif"); 65 66 67 static final class GroupNode extends FilterNode implements PropertyChangeListener { 68 69 70 final String GROUP_NAME_PATTERN = NbBundle.getMessage( 71 ImportViewNodes.class, "FMT_ImportViewNodes_GroupName" ); 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 100 public String getName() { 101 return group.getName(); 102 103 } 104 105 public String getDisplayName() { 106 return MessageFormat.format( GROUP_NAME_PATTERN, 107 new Object [] { group.getDisplayName(), pi.getDisplayName(), getOriginal().getDisplayName() } ); 108 109 } 110 111 public String getShortDescription() { 112 FileObject gdir = group.getRootFolder(); 113 String dir = FileUtil.getFileDisplayName(gdir); 114 return NbBundle.getMessage(ImportViewNodes.class, 115 "HINT_group", 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 return false; 130 } 131 132 public boolean canDestroy() { 133 return false; 134 } 135 136 public Action [] getActions( boolean context ) { 137 138 if ( context ) { 139 return super.getActions( true ); 140 } 141 else { 142 Action [] folderActions = super.getActions( false ); 143 return folderActions; 144 } 145 } 146 147 149 public void propertyChange(PropertyChangeEvent evt) { 150 String 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 } else if ( "name".equals(prop) ) { fireNameChange(null, null); 159 } else if ( "displayName".equals(prop) ) { fireDisplayNameChange(null, null); 161 } else if ( "icon".equals(prop) ) { } else if ( "rootFolder".equals(prop) ) { fireNameChange(null, null); 166 fireDisplayNameChange(null, null); 167 fireShortDescriptionChange(null, null); 168 } else { 169 } 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 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 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 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 key) { 274 275 FileObject folder = null; 276 277 if ( key instanceof Key ) { 278 folder = ((Key)key).folder; 279 Node delegate = null; 280 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 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 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 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 getKeys() { 330 FileObject files[] = fo.getChildren(); 331 ArrayList children = new ArrayList ( files.length ); 332 333 for( int i = 0; i < files.length; i++ ) { 334 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 children.add( new Key( files[i] ) ); 344 } 345 } 346 347 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 , Serializable { 368 369 public int compare(Object arg0, Object 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 getIcon(int type) { 408 Image 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 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 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 if(group.equals(ownerGroup)) { 444 break; 445 } 446 result = isFileExistInRootFolder(group.getRootFolder()); 447 if(result) { 448 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 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 getFileName() { 508 return fileObject.getNameExt(); 509 } 510 } 511 512 516 private static Image loadImage(String path) { 517 return (new ImageIcon (ImportViewNodes.class.getClassLoader().getResource(path))).getImage(); 518 } 519 } 520 | Popular Tags |