1 11 12 package org.eclipse.ui.views.markers.internal; 13 14 import java.util.ArrayList ; 15 import java.util.Arrays ; 16 import java.util.Collection ; 17 import java.util.Collections ; 18 import java.util.HashSet ; 19 import java.util.Iterator ; 20 import java.util.List ; 21 import java.util.Set ; 22 import java.util.StringTokenizer ; 23 24 import org.eclipse.core.resources.IContainer; 25 import org.eclipse.core.resources.IMarker; 26 import org.eclipse.core.resources.IProject; 27 import org.eclipse.core.resources.IResource; 28 import org.eclipse.core.resources.ResourcesPlugin; 29 import org.eclipse.core.resources.mapping.ResourceMapping; 30 import org.eclipse.core.runtime.CoreException; 31 import org.eclipse.core.runtime.IAdaptable; 32 import org.eclipse.core.runtime.IProgressMonitor; 33 import org.eclipse.jface.dialogs.IDialogSettings; 34 import org.eclipse.ui.IMemento; 35 import org.eclipse.ui.IWorkingSet; 36 import org.eclipse.ui.PlatformUI; 37 38 43 public class MarkerFilter implements Cloneable { 44 45 static final String TAG_ENABLED = "enabled"; 47 private static final String TAG_ON_RESOURCE = "onResource"; 49 private static final String TAG_SELECTED_TYPES = "selectedType"; 51 private static final String TAG_WORKING_SET = "workingSet"; 53 private static final String TAG_TYPES_DELIMITER = ":"; 55 58 private static final String TAG_SELECTION_STATUS = "selectionStatus"; 60 63 private static final String SELECTED_FALSE = "false"; 65 68 private static final String SELECTED_TRUE = "true"; 70 73 public static final int ON_ANY = 0; 74 75 78 public static final int ON_SELECTED_ONLY = 1; 79 80 83 public static final int ON_SELECTED_AND_CHILDREN = 2; 84 85 88 public static final int ON_ANY_IN_SAME_CONTAINER = 3; 89 90 93 public static final int ON_WORKING_SET = 4; 94 95 static final int DEFAULT_ON_RESOURCE = ON_ANY; 96 97 static final boolean DEFAULT_ACTIVATION_STATUS = true; 98 99 protected List rootTypes = new ArrayList (); 100 101 protected List selectedTypes = new ArrayList (); 102 103 protected IWorkingSet workingSet; 104 105 protected int onResource; 106 107 protected boolean enabled; 108 109 private IResource[] focusResource; 110 111 private Set cachedWorkingSet; 112 113 private String name; 115 116 124 MarkerFilter(String filterName, String [] rootTypes) { 125 126 name = filterName; 127 128 for (int i = 0; i < rootTypes.length; i++) { 129 MarkerType type = MarkerTypesModel.getInstance().getType( 130 rootTypes[i]); 131 132 if (!this.rootTypes.contains(type)) { 133 this.rootTypes.add(type); 134 } 135 } 136 resetState(); 137 } 138 139 145 public void addAllSubTypes(List types) { 146 for (int i = 0; i < rootTypes.size(); i++) { 147 MarkerType rootType = (MarkerType) rootTypes.get(i); 148 addAllSubTypes(types, rootType); 149 } 150 } 151 152 private void addAllSubTypes(List types, MarkerType type) { 153 if (type == null) { 154 return; 155 } 156 157 if (!types.contains(type)) { 158 types.add(type); 159 } 160 161 MarkerType[] subTypes = type.getSubtypes(); 162 163 for (int i = 0; i < subTypes.length; i++) { 164 addAllSubTypes(types, subTypes[i]); 165 } 166 } 167 168 177 private List findMarkers(IResource[] resources, int depth, int limit, 178 IProgressMonitor mon, boolean ignoreExceptions) 179 throws CoreException { 180 if (resources == null) { 181 return Collections.EMPTY_LIST; 182 } 183 184 List resultList = new ArrayList (resources.length * 2); 185 186 190 HashSet typesToSearch = new HashSet (selectedTypes.size()); 192 193 HashSet includeAllSubtypes = new HashSet (selectedTypes.size()); 196 197 typesToSearch.addAll(selectedTypes); 198 199 Iterator iter = selectedTypes.iterator(); 200 201 while (iter.hasNext()) { 202 MarkerType type = (MarkerType) iter.next(); 203 204 Collection subtypes = Arrays.asList(type.getAllSubTypes()); 205 206 if (selectedTypes.containsAll(subtypes)) { 207 typesToSearch.removeAll(subtypes); 208 209 includeAllSubtypes.add(type); 210 } 211 } 212 213 mon.beginTask(MarkerMessages.MarkerFilter_searching, typesToSearch 214 .size() 215 * resources.length); 216 217 HashSet resourcesToSearch = new HashSet (); 220 221 for (int idx = 0; idx < resources.length; idx++) { 223 IResource next = resources[idx]; 224 225 if (!next.exists()) { 226 continue; 227 } 228 229 if (resourcesToSearch.contains(next)) { 230 mon.worked(typesToSearch.size()); 231 } else { 232 resourcesToSearch.add(next); 233 } 234 } 235 236 for (int resourceIdx = 0; resourceIdx < resources.length; resourceIdx++) { 238 iter = typesToSearch.iterator(); 239 240 IResource resource = resources[resourceIdx]; 241 242 if (!resource.isAccessible()) { 244 continue; 245 } 246 247 if (depth == IResource.DEPTH_INFINITE) { 248 IResource parent = resource.getParent(); 251 boolean found = false; 252 while (parent != null) { 253 if (resourcesToSearch.contains(parent)) { 254 found = true; 255 } 256 257 parent = parent.getParent(); 258 } 259 260 if (found) { 264 continue; 265 } 266 } 267 268 while (iter.hasNext()) { 270 MarkerType markerType = (MarkerType) iter.next(); 271 272 IMarker[] markers = resource.findMarkers(markerType.getId(), 275 includeAllSubtypes.contains(markerType), depth); 276 277 mon.worked(1); 278 279 for (int idx = 0; idx < markers.length; idx++) { 280 ConcreteMarker marker; 281 try { 282 marker = MarkerList.createMarker(markers[idx]); 283 } catch (CoreException e) { 284 if (ignoreExceptions) { 285 continue; 286 } 287 throw e; 288 289 } 290 291 if (limit != -1 && resultList.size() >= limit) { 292 return resultList; 293 } 294 295 if (selectMarker(marker)) { 296 resultList.add(marker); 297 } 298 } 299 } 300 } 301 302 mon.done(); 303 304 return resultList; 305 } 306 307 315 protected boolean selectMarker(ConcreteMarker marker) { 316 return true; 317 } 318 319 324 Collection findMarkers(IProgressMonitor mon, boolean ignoreExceptions) 325 throws CoreException { 326 327 List unfiltered = Collections.EMPTY_LIST; 328 329 if (!isEnabled()) { 330 unfiltered = findMarkers(new IResource[] { ResourcesPlugin 331 .getWorkspace().getRoot() }, IResource.DEPTH_INFINITE, -1, 332 mon, ignoreExceptions); 333 } else { 334 int limit = -1; 336 337 switch (getOnResource()) { 338 case ON_ANY: { 339 unfiltered = findMarkers(new IResource[] { ResourcesPlugin 340 .getWorkspace().getRoot() }, IResource.DEPTH_INFINITE, 341 limit, mon, ignoreExceptions); 342 break; 343 } 344 case ON_SELECTED_ONLY: { 345 unfiltered = findMarkers(focusResource, IResource.DEPTH_ZERO, 346 limit, mon, ignoreExceptions); 347 break; 348 } 349 case ON_SELECTED_AND_CHILDREN: { 350 unfiltered = findMarkers(focusResource, 351 IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions); 352 break; 353 } 354 case ON_ANY_IN_SAME_CONTAINER: { 355 unfiltered = findMarkers(getProjects(focusResource), 356 IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions); 357 break; 358 } 359 case ON_WORKING_SET: { 360 unfiltered = findMarkers(getResourcesInWorkingSet(), 361 IResource.DEPTH_INFINITE, limit, mon, ignoreExceptions); 362 } 363 } 364 } 365 366 if (unfiltered == null) { 367 unfiltered = Collections.EMPTY_LIST; 368 } 369 370 return unfiltered; 371 } 372 373 379 IResource[] getResourcesInWorkingSet() { 380 if (workingSet == null) { 381 return new IResource[0]; 382 } 383 384 if (workingSet.isEmpty()) { 385 return new IResource[] { ResourcesPlugin.getWorkspace().getRoot() }; 386 } 387 388 IAdaptable[] elements = workingSet.getElements(); 389 List result = new ArrayList (elements.length); 390 391 for (int idx = 0; idx < elements.length; idx++) { 392 IResource next = (IResource) elements[idx] 393 .getAdapter(IResource.class); 394 395 if (next != null) { 396 result.add(next); 397 } 398 } 399 400 return (IResource[]) result.toArray(new IResource[result.size()]); 401 } 402 403 410 private Set getWorkingSetAsSetOfPaths() { 411 if (cachedWorkingSet == null) { 412 HashSet result = new HashSet (); 413 414 addResourcesAndChildren(result, getResourcesInWorkingSet()); 415 416 cachedWorkingSet = result; 417 } 418 419 return cachedWorkingSet; 420 } 421 422 425 private void addResourcesAndChildren(HashSet result, IResource[] resources) { 426 for (int idx = 0; idx < resources.length; idx++) { 427 428 IResource currentResource = resources[idx]; 429 430 result.add(currentResource.getFullPath().toString()); 431 432 if (currentResource instanceof IContainer) { 433 IContainer cont = (IContainer) currentResource; 434 435 try { 436 addResourcesAndChildren(result, cont.members()); 437 } catch (CoreException e) { 438 } 440 } 441 442 } 443 } 444 445 451 static IProject[] getProjects(IResource[] resources) { 452 if (resources == null) { 453 return new IProject[0]; 454 } 455 456 Collection projects = getProjectsAsCollection(resources); 457 458 return (IProject[]) projects.toArray(new IProject[projects.size()]); 459 } 460 461 468 static Collection getProjectsAsCollection(Object [] elements) { 469 HashSet projects = new HashSet (); 470 471 for (int idx = 0; idx < elements.length; idx++) { 472 if (elements[idx] instanceof IResource) { 473 projects.add(((IResource) elements[idx]).getProject()); 474 } else { 475 IProject[] mappingProjects = (((ResourceMapping) elements[idx]) 476 .getProjects()); 477 for (int i = 0; i < mappingProjects.length; i++) { 478 projects.add(mappingProjects[i]); 479 } 480 } 481 482 } 483 484 return projects; 485 } 486 487 493 public boolean select(ConcreteMarker marker) { 494 if (!isEnabled()) { 495 return true; 496 } 497 498 return selectByType(marker) && selectBySelection(marker) 499 && selectMarker(marker); 500 } 501 502 private boolean selectByType(ConcreteMarker marker) { 503 return selectedTypes.contains(MarkerTypesModel.getInstance().getType( 504 marker.getType())); 505 } 506 507 515 private boolean selectBySelection(ConcreteMarker marker) { 516 if (onResource == ON_ANY || marker == null) { 517 return true; 518 } 519 520 if (focusResource == null) { 521 return true; 522 } 523 524 IResource resource = marker.getResource(); 525 526 if (onResource == ON_WORKING_SET) { 527 528 if (resource != null) { 529 return isEnclosed(resource); 530 } 531 532 } else if (onResource == ON_ANY_IN_SAME_CONTAINER) { 533 IProject project = resource.getProject(); 534 535 if (project == null) { 536 return false; 537 } 538 539 for (int i = 0; i < focusResource.length; i++) { 540 IProject selectedProject = focusResource[i].getProject(); 541 542 if (selectedProject == null) { 543 continue; 544 } 545 546 if (project.equals(selectedProject)) { 547 return true; 548 } 549 } 550 } else if (onResource == ON_SELECTED_ONLY) { 551 for (int i = 0; i < focusResource.length; i++) { 552 if (resource.equals(focusResource[i])) { 553 return true; 554 } 555 } 556 } else if (onResource == ON_SELECTED_AND_CHILDREN) { 557 for (int i = 0; i < focusResource.length; i++) { 558 IResource parentResource = resource; 559 560 while (parentResource != null) { 561 if (parentResource.equals(focusResource[i])) { 562 return true; 563 } 564 565 parentResource = parentResource.getParent(); 566 } 567 } 568 } 569 570 return false; 571 } 572 573 584 private boolean isEnclosed(IResource element) { 585 if (workingSet == null) { 586 return false; 587 } 588 589 if (workingSet.isEmpty()) { 590 return true; } 592 Set workingSetPaths = getWorkingSetAsSetOfPaths(); 593 594 return workingSetPaths.contains(element.getFullPath().toString()); 595 } 596 597 614 public int getOnResource() { 615 return onResource; 616 } 617 618 631 void setOnResource(int onResource) { 632 if (onResource >= ON_ANY && onResource <= ON_WORKING_SET) { 633 this.onResource = onResource; 634 } 635 } 636 637 640 IResource[] getFocusResource() { 641 return focusResource; 642 } 643 644 649 public void setFocusResource(IResource[] resources) { 650 focusResource = resources; 651 } 652 653 660 public boolean isEnabled() { 661 return enabled; 662 } 663 664 670 public List getRootTypes() { 671 return rootTypes; 672 } 673 674 680 public List getSelectedTypes() { 681 return selectedTypes; 682 } 683 684 691 public MarkerType getMarkerType(String id) { 692 return MarkerTypesModel.getInstance().getType(id); 693 } 694 695 699 IWorkingSet getWorkingSet() { 700 return workingSet; 701 } 702 703 706 void setEnabled(boolean enabled) { 707 this.enabled = enabled; 708 } 709 710 713 void setWorkingSet(IWorkingSet workingSet) { 714 this.workingSet = workingSet; 715 cachedWorkingSet = null; 716 } 717 718 721 void resetState() { 722 enabled = DEFAULT_ACTIVATION_STATUS; 723 onResource = DEFAULT_ON_RESOURCE; 724 selectedTypes.clear(); 725 addAllSubTypes(selectedTypes); 726 setWorkingSet(null); 727 } 728 729 734 public final void restoreState(IMemento memento) { 735 resetState(); 736 restoreFilterSettings(memento); 737 738 } 739 740 746 public void restoreFilterSettings(IDialogSettings settings) { 747 748 resetState(); 749 750 String setting = settings.get(TAG_ENABLED); 751 752 if (setting != null) { 753 enabled = Boolean.valueOf(setting).booleanValue(); 754 } 755 756 setting = settings.get(TAG_ON_RESOURCE); 757 758 if (setting != null) { 759 try { 760 onResource = Integer.parseInt(setting); 761 } catch (NumberFormatException eNumberFormat) { 762 } 763 } 764 765 setting = settings.get(TAG_SELECTION_STATUS); 768 769 if (setting != null) { 770 selectedTypes.clear(); 771 772 List newTypes = new ArrayList (); 774 addAllSubTypes(newTypes); 775 776 StringTokenizer stringTokenizer = new StringTokenizer (setting); 777 778 while (stringTokenizer.hasMoreTokens()) { 779 String id = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); 780 String status = null; 781 if (stringTokenizer.hasMoreTokens()) { 782 status = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); 783 } 784 785 MarkerType markerType = MarkerTypesModel.getInstance().getType( 786 id); 787 if (markerType != null) { 788 newTypes.remove(markerType); 789 790 if (!SELECTED_FALSE.equals(status) 792 && !selectedTypes.contains(markerType)) { 793 selectedTypes.add(markerType); 794 } 795 } 796 } 797 798 for (int i = 0; i < newTypes.size(); ++i) { 802 selectedTypes.add(newTypes.get(i)); 803 } 804 } else { 805 setting = settings.get(TAG_SELECTED_TYPES); 809 810 if (setting != null) { 811 generateSelectedTypes(setting); 812 } 813 814 } 815 816 setting = settings.get(TAG_WORKING_SET); 817 818 if (setting != null) { 819 setWorkingSet(PlatformUI.getWorkbench().getWorkingSetManager() 820 .getWorkingSet(setting)); 821 } 822 } 823 824 829 void generateSelectedTypes(String selectedTypesValue) { 830 selectedTypes.clear(); 831 StringTokenizer stringTokenizer = new StringTokenizer ( 832 selectedTypesValue); 833 834 while (stringTokenizer.hasMoreTokens()) { 835 MarkerType markerType = getMarkerType(stringTokenizer 836 .nextToken(TAG_TYPES_DELIMITER)); 837 838 if (markerType != null && !selectedTypes.contains(markerType)) { 839 selectedTypes.add(markerType); 840 } 841 } 842 } 843 844 850 MarkerType findMarkerType(String typeName) { 851 return MarkerTypesModel.getInstance().getType(typeName); 852 } 853 854 859 protected void restoreFilterSettings(IMemento memento) { 860 String setting = memento.getString(TAG_ENABLED); 861 862 if (setting != null) { 863 enabled = Boolean.valueOf(setting).booleanValue(); 864 } 865 866 Integer resourceSetting = memento.getInteger(TAG_ON_RESOURCE); 867 868 if (resourceSetting != null) { 869 onResource = resourceSetting.intValue(); 870 } 871 872 setting = memento.getString(TAG_SELECTION_STATUS); 875 876 if (setting != null) { 877 selectedTypes.clear(); 878 879 List newTypes = new ArrayList (); 881 addAllSubTypes(newTypes); 882 883 StringTokenizer stringTokenizer = new StringTokenizer (setting); 884 885 while (stringTokenizer.hasMoreTokens()) { 886 String id = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); 887 String status = null; 888 if (stringTokenizer.hasMoreTokens()) { 889 status = stringTokenizer.nextToken(TAG_TYPES_DELIMITER); 890 } 891 892 MarkerType markerType = MarkerTypesModel.getInstance().getType( 893 id); 894 if (markerType != null) { 895 newTypes.remove(markerType); 896 897 if (!SELECTED_FALSE.equals(status) 899 && !selectedTypes.contains(markerType)) { 900 selectedTypes.add(markerType); 901 } 902 } 903 } 904 905 for (int i = 0; i < newTypes.size(); ++i) { 909 selectedTypes.add(newTypes.get(i)); 910 } 911 } else { 912 setting = memento.getString(TAG_SELECTED_TYPES); 916 917 if (setting != null) { 918 generateSelectedTypes(setting); 919 } 920 921 } 922 923 setting = memento.getString(TAG_WORKING_SET); 924 925 if (setting != null) { 926 setWorkingSet(PlatformUI.getWorkbench().getWorkingSetManager() 927 .getWorkingSet(setting)); 928 } 929 } 930 931 936 public void saveFilterSettings(IMemento settings) { 937 938 settings.putString(TAG_ENABLED, String.valueOf(enabled)); 939 settings.putInteger(TAG_ON_RESOURCE, onResource); 940 941 String markerTypeIds = ""; 943 List includedTypes = new ArrayList (); 944 addAllSubTypes(includedTypes); 945 for (int i = 0; i < includedTypes.size(); i++) { 946 MarkerType markerType = (MarkerType) includedTypes.get(i); 947 markerTypeIds += markerType.getId() + TAG_TYPES_DELIMITER; 948 if (selectedTypes.contains(markerType)) { 949 markerTypeIds += SELECTED_TRUE + TAG_TYPES_DELIMITER; 950 } else { 951 markerTypeIds += SELECTED_FALSE + TAG_TYPES_DELIMITER; 952 } 953 } 954 955 settings.putString(TAG_SELECTION_STATUS, markerTypeIds); 956 957 if (workingSet != null) { 958 settings.putString(TAG_WORKING_SET, workingSet.getName()); 959 } 960 } 961 962 967 public String getName() { 968 return name; 969 } 970 971 977 public MarkerFilter makeClone() throws CloneNotSupportedException { 978 return (MarkerFilter) this.clone(); 979 } 980 981 987 public void setSelectedTypes(List selectedTypes) { 988 this.selectedTypes = selectedTypes; 989 } 990 991 } 992 | Popular Tags |