001: /*******************************************************************************
002: * Copyright (c) 2000, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.ui.dialogs;
011:
012: import java.io.IOException;
013: import java.io.StringReader;
014: import java.io.StringWriter;
015: import java.util.ArrayList;
016: import java.util.Arrays;
017: import java.util.Comparator;
018: import java.util.List;
019:
020: import org.eclipse.core.resources.IContainer;
021: import org.eclipse.core.resources.IResource;
022: import org.eclipse.core.resources.IResourceProxy;
023: import org.eclipse.core.resources.IResourceProxyVisitor;
024: import org.eclipse.core.resources.IWorkspace;
025: import org.eclipse.core.resources.ResourcesPlugin;
026: import org.eclipse.core.runtime.CoreException;
027: import org.eclipse.core.runtime.IProgressMonitor;
028: import org.eclipse.core.runtime.IStatus;
029: import org.eclipse.core.runtime.ListenerList;
030: import org.eclipse.core.runtime.Status;
031: import org.eclipse.jface.action.Action;
032: import org.eclipse.jface.action.IAction;
033: import org.eclipse.jface.action.IMenuManager;
034: import org.eclipse.jface.action.Separator;
035: import org.eclipse.jface.dialogs.IDialogSettings;
036: import org.eclipse.jface.text.ITextSelection;
037: import org.eclipse.jface.util.IPropertyChangeListener;
038: import org.eclipse.jface.util.PropertyChangeEvent;
039: import org.eclipse.jface.viewers.ILabelDecorator;
040: import org.eclipse.jface.viewers.ILabelProviderListener;
041: import org.eclipse.jface.viewers.ISelection;
042: import org.eclipse.jface.viewers.LabelProvider;
043: import org.eclipse.jface.viewers.LabelProviderChangedEvent;
044: import org.eclipse.jface.viewers.Viewer;
045: import org.eclipse.jface.viewers.ViewerFilter;
046: import org.eclipse.swt.graphics.Image;
047: import org.eclipse.swt.widgets.Composite;
048: import org.eclipse.swt.widgets.Control;
049: import org.eclipse.swt.widgets.Shell;
050: import org.eclipse.ui.IMemento;
051: import org.eclipse.ui.IWorkbenchPage;
052: import org.eclipse.ui.IWorkbenchWindow;
053: import org.eclipse.ui.IWorkingSet;
054: import org.eclipse.ui.PlatformUI;
055: import org.eclipse.ui.ResourceWorkingSetFilter;
056: import org.eclipse.ui.WorkbenchException;
057: import org.eclipse.ui.XMLMemento;
058: import org.eclipse.ui.actions.WorkingSetFilterActionGroup;
059: import org.eclipse.ui.internal.WorkbenchMessages;
060: import org.eclipse.ui.internal.WorkbenchPlugin;
061: import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
062: import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
063: import org.eclipse.ui.internal.ide.IIDEHelpContextIds;
064: import org.eclipse.ui.internal.ide.model.ResourceFactory;
065: import org.eclipse.ui.model.WorkbenchLabelProvider;
066: import org.eclipse.ui.statushandlers.StatusManager;
067:
068: import com.ibm.icu.text.Collator;
069:
070: /**
071: * Shows a list of resources to the user with a text entry field for a string
072: * pattern used to filter the list of resources.
073: *
074: * @since 3.3
075: */
076: public class FilteredResourcesSelectionDialog extends
077: FilteredItemsSelectionDialog {
078:
079: private static final String DIALOG_SETTINGS = "org.eclipse.ui.dialogs.FilteredResourcesSelectionDialog"; //$NON-NLS-1$
080:
081: private static final String WORKINGS_SET_SETTINGS = "WorkingSet"; //$NON-NLS-1$
082:
083: private static final String SHOW_DERIVED = "ShowDerived"; //$NON-NLS-1$
084:
085: private ShowDerivedResourcesAction showDerivedResourcesAction;
086:
087: private ResourceItemLabelProvider resourceItemLabelProvider;
088:
089: private ResourceItemDetailsLabelProvider resourceItemDetailsLabelProvider;
090:
091: private WorkingSetFilterActionGroup workingSetFilterActionGroup;
092:
093: private CustomWorkingSetFilter workingSetFilter = new CustomWorkingSetFilter();
094:
095: private String title;
096:
097: private IContainer container;
098:
099: private int typeMask;
100:
101: private boolean isDerived;
102:
103: /**
104: * Creates a new instance of the class
105: *
106: * @param shell
107: * the parent shell
108: * @param multi
109: * the multi selection flag
110: * @param container
111: * the container
112: * @param typesMask
113: * the types mask
114: */
115: public FilteredResourcesSelectionDialog(Shell shell, boolean multi,
116: IContainer container, int typesMask) {
117: super (shell, multi);
118:
119: setSelectionHistory(new ResourceSelectionHistory());
120:
121: setTitle(IDEWorkbenchMessages.OpenResourceDialog_title);
122: PlatformUI.getWorkbench().getHelpSystem().setHelp(shell,
123: IIDEHelpContextIds.OPEN_RESOURCE_DIALOG);
124:
125: this .container = container;
126: this .typeMask = typesMask;
127:
128: resourceItemLabelProvider = new ResourceItemLabelProvider();
129:
130: resourceItemDetailsLabelProvider = new ResourceItemDetailsLabelProvider();
131:
132: setListLabelProvider(resourceItemLabelProvider);
133: setDetailsLabelProvider(resourceItemDetailsLabelProvider);
134: }
135:
136: /*
137: * (non-Javadoc)
138: *
139: * @see org.eclipse.ui.dialogs.SelectionDialog#setTitle(java.lang.String)
140: */
141: public void setTitle(String title) {
142: super .setTitle(title);
143: this .title = title;
144: }
145:
146: /**
147: * Adds or replaces subtitle of the dialog
148: *
149: * @param text
150: * the new subtitle
151: */
152: private void setSubtitle(String text) {
153: if (text == null || text.length() == 0) {
154: getShell().setText(title);
155: } else {
156: getShell().setText(title + " - " + text); //$NON-NLS-1$
157: }
158: }
159:
160: /*
161: * (non-Javadoc)
162: *
163: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#getDialogSettings()
164: */
165: protected IDialogSettings getDialogSettings() {
166: IDialogSettings settings = IDEWorkbenchPlugin.getDefault()
167: .getDialogSettings().getSection(DIALOG_SETTINGS);
168:
169: if (settings == null) {
170: settings = IDEWorkbenchPlugin.getDefault()
171: .getDialogSettings().addNewSection(DIALOG_SETTINGS);
172: }
173:
174: return settings;
175: }
176:
177: /*
178: * (non-Javadoc)
179: *
180: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#storeDialog(org.eclipse.jface.dialogs.IDialogSettings)
181: */
182: protected void storeDialog(IDialogSettings settings) {
183: super .storeDialog(settings);
184:
185: settings.put(SHOW_DERIVED, showDerivedResourcesAction
186: .isChecked());
187:
188: XMLMemento memento = XMLMemento.createWriteRoot("workingSet"); //$NON-NLS-1$
189: workingSetFilterActionGroup.saveState(memento);
190: workingSetFilterActionGroup.dispose();
191: StringWriter writer = new StringWriter();
192: try {
193: memento.save(writer);
194: settings.put(WORKINGS_SET_SETTINGS, writer.getBuffer()
195: .toString());
196: } catch (IOException e) {
197: StatusManager.getManager().handle(
198: new Status(IStatus.ERROR,
199: WorkbenchPlugin.PI_WORKBENCH,
200: IStatus.ERROR, "", e)); //$NON-NLS-1$
201: // don't do anything. Simply don't store the settings
202: }
203: }
204:
205: /*
206: * (non-Javadoc)
207: *
208: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#restoreDialog(org.eclipse.jface.dialogs.IDialogSettings)
209: */
210: protected void restoreDialog(IDialogSettings settings) {
211: super .restoreDialog(settings);
212:
213: boolean showDerived = settings.getBoolean(SHOW_DERIVED);
214: showDerivedResourcesAction.setChecked(showDerived);
215: this .isDerived = showDerived;
216:
217: String setting = settings.get(WORKINGS_SET_SETTINGS);
218: if (setting != null) {
219: try {
220: IMemento memento = XMLMemento
221: .createReadRoot(new StringReader(setting));
222: workingSetFilterActionGroup.restoreState(memento);
223: } catch (WorkbenchException e) {
224: StatusManager.getManager().handle(
225: new Status(IStatus.ERROR,
226: WorkbenchPlugin.PI_WORKBENCH,
227: IStatus.ERROR, "", e)); //$NON-NLS-1$
228: // don't do anything. Simply don't restore the settings
229: }
230: }
231:
232: addListFilter(workingSetFilter);
233:
234: applyFilter();
235: }
236:
237: /*
238: * (non-Javadoc)
239: *
240: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#fillViewMenu(org.eclipse.jface.action.IMenuManager)
241: */
242: protected void fillViewMenu(IMenuManager menuManager) {
243: super .fillViewMenu(menuManager);
244:
245: showDerivedResourcesAction = new ShowDerivedResourcesAction();
246: menuManager.add(showDerivedResourcesAction);
247:
248: workingSetFilterActionGroup = new WorkingSetFilterActionGroup(
249: getShell(), new IPropertyChangeListener() {
250: public void propertyChange(PropertyChangeEvent event) {
251: String property = event.getProperty();
252:
253: if (WorkingSetFilterActionGroup.CHANGE_WORKING_SET
254: .equals(property)) {
255:
256: IWorkingSet workingSet = (IWorkingSet) event
257: .getNewValue();
258:
259: if (workingSet != null
260: && !(workingSet
261: .isAggregateWorkingSet() && workingSet
262: .isEmpty())) {
263: workingSetFilter
264: .setWorkingSet(workingSet);
265: setSubtitle(workingSet.getLabel());
266: } else {
267: IWorkbenchWindow window = PlatformUI
268: .getWorkbench()
269: .getActiveWorkbenchWindow();
270:
271: if (window != null) {
272: IWorkbenchPage page = window
273: .getActivePage();
274: workingSet = page
275: .getAggregateWorkingSet();
276:
277: if (workingSet
278: .isAggregateWorkingSet()
279: && workingSet.isEmpty()) {
280: workingSet = null;
281: }
282: }
283:
284: workingSetFilter
285: .setWorkingSet(workingSet);
286: setSubtitle(null);
287: }
288:
289: scheduleRefresh();
290: }
291: }
292: });
293:
294: menuManager.add(new Separator());
295: workingSetFilterActionGroup.fillContextMenu(menuManager);
296: }
297:
298: /*
299: * (non-Javadoc)
300: *
301: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#createExtendedContentArea(org.eclipse.swt.widgets.Composite)
302: */
303: protected Control createExtendedContentArea(Composite parent) {
304: return null;
305: }
306:
307: /*
308: * (non-Javadoc)
309: *
310: * @see org.eclipse.ui.dialogs.SelectionDialog#getResult()
311: */
312: public Object[] getResult() {
313: Object[] result = super .getResult();
314:
315: if (result == null)
316: return null;
317:
318: List resultToReturn = new ArrayList();
319:
320: for (int i = 0; i < result.length; i++) {
321: if (result[i] instanceof IResource) {
322: resultToReturn.add((result[i]));
323: }
324: }
325:
326: return resultToReturn.toArray();
327: }
328:
329: /*
330: * (non-Javadoc)
331: *
332: * @see org.eclipse.jface.window.Window#open()
333: */
334: public int open() {
335: if (getInitialPattern() == null) {
336: IWorkbenchWindow window = PlatformUI.getWorkbench()
337: .getActiveWorkbenchWindow();
338: if (window != null) {
339: ISelection selection = window.getSelectionService()
340: .getSelection();
341: if (selection instanceof ITextSelection) {
342: String text = ((ITextSelection) selection)
343: .getText();
344: if (text != null) {
345: text = text.trim();
346: if (text.length() > 0) {
347: IWorkspace workspace = ResourcesPlugin
348: .getWorkspace();
349: IStatus result = workspace.validateName(
350: text, IResource.FILE);
351: if (result.isOK()) {
352: setInitialPattern(text);
353: }
354: }
355: }
356: }
357: }
358: }
359: return super .open();
360: }
361:
362: /*
363: * (non-Javadoc)
364: *
365: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#getElementName(java.lang.Object)
366: */
367: public String getElementName(Object item) {
368: IResource resource = (IResource) item;
369: return resource.getName();
370: }
371:
372: /*
373: * (non-Javadoc)
374: *
375: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#validateItem(java.lang.Object)
376: */
377: protected IStatus validateItem(Object item) {
378: return new Status(IStatus.OK, WorkbenchPlugin.PI_WORKBENCH, 0,
379: "", null); //$NON-NLS-1$
380: }
381:
382: /*
383: * (non-Javadoc)
384: *
385: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#createFilter()
386: */
387: protected ItemsFilter createFilter() {
388: return new ResourceFilter(container, isDerived, typeMask);
389: }
390:
391: /* (non-Javadoc)
392: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#applyFilter()
393: */
394: protected void applyFilter() {
395: super .applyFilter();
396: }
397:
398: /*
399: * (non-Javadoc)
400: *
401: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#getItemsComparator()
402: */
403: protected Comparator getItemsComparator() {
404: return new Comparator() {
405:
406: /*
407: * (non-Javadoc)
408: *
409: * @see java.util.Comparator#compare(java.lang.Object,
410: * java.lang.Object)
411: */
412: public int compare(Object o1, Object o2) {
413: Collator collator = Collator.getInstance();
414: IResource resource1 = (IResource) o1;
415: IResource resource2 = (IResource) o2;
416: String s1 = resource1.getName();
417: String s2 = resource2.getName();
418: int comparability = collator.compare(s1, s2);
419: if (comparability == 0) {
420: s1 = resource1.getFullPath().toString();
421: s2 = resource2.getFullPath().toString();
422: comparability = collator.compare(s1, s2);
423: }
424:
425: return comparability;
426: }
427: };
428: }
429:
430: /*
431: * (non-Javadoc)
432: *
433: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog#fillContentProvider(org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.AbstractContentProvider,
434: * org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter,
435: * org.eclipse.core.runtime.IProgressMonitor)
436: */
437: protected void fillContentProvider(
438: AbstractContentProvider contentProvider,
439: ItemsFilter itemsFilter, IProgressMonitor progressMonitor)
440: throws CoreException {
441: if (itemsFilter instanceof ResourceFilter)
442: container.accept(new ResourceProxyVisitor(contentProvider,
443: (ResourceFilter) itemsFilter, progressMonitor),
444: IResource.NONE);
445: if (progressMonitor != null)
446: progressMonitor.done();
447:
448: }
449:
450: /**
451: * Sets the derived flag on the ResourceFilter instance
452: */
453: private class ShowDerivedResourcesAction extends Action {
454:
455: /**
456: * Creates a new instance of the action.
457: */
458: public ShowDerivedResourcesAction() {
459: super (
460: IDEWorkbenchMessages.FilteredResourcesSelectionDialog_showDerivedResourcesAction,
461: IAction.AS_CHECK_BOX);
462: }
463:
464: public void run() {
465: FilteredResourcesSelectionDialog.this .isDerived = isChecked();
466: applyFilter();
467: }
468: }
469:
470: /**
471: * A label provider for ResourceDecorator objects. It creates labels with a
472: * resource full path for duplicates. It uses the Platform UI label
473: * decorator for providing extra resource info.
474: */
475: private class ResourceItemLabelProvider extends LabelProvider
476: implements ILabelProviderListener {
477:
478: // Need to keep our own list of listeners
479: private ListenerList listeners = new ListenerList();
480:
481: WorkbenchLabelProvider provider = new WorkbenchLabelProvider();
482:
483: ILabelDecorator decorator = PlatformUI.getWorkbench()
484: .getDecoratorManager().getLabelDecorator();
485:
486: /**
487: * Creates a new instance of the class
488: */
489: public ResourceItemLabelProvider() {
490: super ();
491: provider.addListener(this );
492: decorator.addListener(this );
493: }
494:
495: /*
496: * (non-Javadoc)
497: *
498: * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
499: */
500: public Image getImage(Object element) {
501: if (!(element instanceof IResource)) {
502: return super .getImage(element);
503: }
504:
505: IResource res = (IResource) element;
506:
507: Image img = provider.getImage(res);
508:
509: return decorator.decorateImage(img, res);
510: }
511:
512: /*
513: * (non-Javadoc)
514: *
515: * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
516: */
517: public String getText(Object element) {
518: if (!(element instanceof IResource)) {
519: return super .getText(element);
520: }
521:
522: IResource res = (IResource) element;
523:
524: String str = res.getName();
525:
526: // extra info for duplicates
527: if (isDuplicateElement(element))
528: str = str
529: + " - " + res.getParent().getFullPath().makeRelative().toString(); //$NON-NLS-1$
530:
531: return decorator.decorateText(str, res);
532: }
533:
534: /*
535: * (non-Javadoc)
536: *
537: * @see org.eclipse.jface.viewers.LabelProvider#dispose()
538: */
539: public void dispose() {
540: provider.removeListener(this );
541: provider.dispose();
542:
543: decorator.removeListener(this );
544: decorator.dispose();
545:
546: super .dispose();
547: }
548:
549: /*
550: * (non-Javadoc)
551: *
552: * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)
553: */
554: public void addListener(ILabelProviderListener listener) {
555: listeners.add(listener);
556: }
557:
558: /*
559: * (non-Javadoc)
560: *
561: * @see org.eclipse.jface.viewers.LabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)
562: */
563: public void removeListener(ILabelProviderListener listener) {
564: listeners.remove(listener);
565: }
566:
567: /*
568: * (non-Javadoc)
569: *
570: * @see org.eclipse.jface.viewers.ILabelProviderListener#labelProviderChanged(org.eclipse.jface.viewers.LabelProviderChangedEvent)
571: */
572: public void labelProviderChanged(LabelProviderChangedEvent event) {
573: Object[] l = listeners.getListeners();
574: for (int i = 0; i < listeners.size(); i++) {
575: ((ILabelProviderListener) l[i])
576: .labelProviderChanged(event);
577: }
578: }
579:
580: }
581:
582: /**
583: * A label provider for details of ResourceItem objects.
584: */
585: private class ResourceItemDetailsLabelProvider extends
586: ResourceItemLabelProvider {
587: /*
588: * (non-Javadoc)
589: *
590: * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
591: */
592: public Image getImage(Object element) {
593: if (!(element instanceof IResource)) {
594: return super .getImage(element);
595: }
596:
597: IResource parent = ((IResource) element).getParent();
598: Image img = provider.getImage(parent);
599:
600: return decorator.decorateImage(img, parent);
601: }
602:
603: /*
604: * (non-Javadoc)
605: *
606: * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
607: */
608: public String getText(Object element) {
609: if (!(element instanceof IResource)) {
610: return super .getText(element);
611: }
612:
613: IResource parent = ((IResource) element).getParent();
614:
615: if (parent.getType() == IResource.ROOT) {
616: // Get readable name for workspace root ("Workspace"), without
617: // duplicating language-specific string here.
618: return super .decorator.decorateText(null, parent);
619: }
620:
621: return super .decorator.decorateText(parent.getFullPath()
622: .makeRelative().toString(), parent);
623: }
624:
625: /*
626: * (non-Javadoc)
627: *
628: * @see org.eclipse.jface.viewers.ILabelProviderListener#labelProviderChanged(org.eclipse.jface.viewers.LabelProviderChangedEvent)
629: */
630: public void labelProviderChanged(LabelProviderChangedEvent event) {
631: Object[] l = super .listeners.getListeners();
632: for (int i = 0; i < super .listeners.size(); i++) {
633: ((ILabelProviderListener) l[i])
634: .labelProviderChanged(event);
635: }
636: }
637: }
638:
639: /**
640: * Viewer filter which filters resources due to current working set
641: */
642: private class CustomWorkingSetFilter extends ViewerFilter {
643: private ResourceWorkingSetFilter resourceWorkingSetFilter = new ResourceWorkingSetFilter();
644:
645: /**
646: * Returns the active working set the filter is working with.
647: *
648: * @return the active working set
649: */
650: public IWorkingSet getWorkingSet() {
651: return resourceWorkingSetFilter.getWorkingSet();
652: }
653:
654: /**
655: * Sets the active working set.
656: *
657: * @param workingSet
658: * the working set the filter should work with
659: */
660: public void setWorkingSet(IWorkingSet workingSet) {
661: resourceWorkingSetFilter.setWorkingSet(workingSet);
662: }
663:
664: /*
665: * (non-Javadoc)
666: *
667: * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
668: * java.lang.Object, java.lang.Object)
669: */
670: public boolean select(Viewer viewer, Object parentElement,
671: Object element) {
672: return resourceWorkingSetFilter.select(viewer,
673: parentElement, element);
674: }
675: }
676:
677: /**
678: * ResourceProxyVisitor to visit resource tree and get matched resources.
679: * During visit resources it updates progress monitor and adds matched
680: * resources to ContentProvider instance.
681: */
682: private class ResourceProxyVisitor implements IResourceProxyVisitor {
683:
684: private AbstractContentProvider proxyContentProvider;
685:
686: private ResourceFilter resourceFilter;
687:
688: private IProgressMonitor progressMonitor;
689:
690: private List projects;
691:
692: /**
693: * Creates new ResourceProxyVisitor instance.
694: *
695: * @param contentProvider
696: * @param resourceFilter
697: * @param progressMonitor
698: * @throws CoreException
699: */
700: public ResourceProxyVisitor(
701: AbstractContentProvider contentProvider,
702: ResourceFilter resourceFilter,
703: IProgressMonitor progressMonitor) throws CoreException {
704: super ();
705: this .proxyContentProvider = contentProvider;
706: this .resourceFilter = resourceFilter;
707: this .progressMonitor = progressMonitor;
708: IResource[] resources = container.members();
709: this .projects = new ArrayList(Arrays.asList(resources));
710:
711: if (progressMonitor != null)
712: progressMonitor
713: .beginTask(
714: WorkbenchMessages.FilteredItemsSelectionDialog_searchJob_taskName,
715: projects.size());
716: }
717:
718: /*
719: * (non-Javadoc)
720: *
721: * @see org.eclipse.core.resources.IResourceProxyVisitor#visit(org.eclipse.core.resources.IResourceProxy)
722: */
723: public boolean visit(IResourceProxy proxy) {
724:
725: if (progressMonitor.isCanceled())
726: return false;
727:
728: IResource resource = proxy.requestResource();
729:
730: if (this .projects.remove((resource.getProject()))
731: || this .projects.remove((resource))) {
732: progressMonitor.worked(1);
733: }
734:
735: proxyContentProvider.add(resource, resourceFilter);
736:
737: if (resource.getType() == IResource.FOLDER
738: && resource.isDerived()
739: && !resourceFilter.isShowDerived()) {
740:
741: return false;
742: }
743:
744: if (resource.getType() == IResource.FILE) {
745: return false;
746: }
747:
748: return true;
749: }
750: }
751:
752: /**
753: * Filters resources using pattern and showDerived flag. It overrides
754: * ItemsFilter.
755: */
756: protected class ResourceFilter extends ItemsFilter {
757:
758: private boolean showDerived = false;
759:
760: private IContainer filterContainer;
761:
762: private int filterTypeMask;
763:
764: /**
765: * Creates new ResourceFilter instance
766: *
767: * @param container
768: * @param showDerived
769: * flag which determine showing derived elements
770: * @param typeMask
771: */
772: public ResourceFilter(IContainer container,
773: boolean showDerived, int typeMask) {
774: super ();
775: this .filterContainer = container;
776: this .showDerived = showDerived;
777: this .filterTypeMask = typeMask;
778: }
779:
780: /**
781: * Creates new ResourceFilter instance
782: */
783: public ResourceFilter() {
784: super ();
785: this .filterContainer = container;
786: this .showDerived = isDerived;
787: this .filterTypeMask = typeMask;
788: }
789:
790: /**
791: * @param item
792: * Must be instance of IResource, otherwise
793: * <code>false</code> will be returned.
794: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter#isConsistentItem(java.lang.Object)
795: */
796: public boolean isConsistentItem(Object item) {
797: if (!(item instanceof IResource)) {
798: return false;
799: }
800: IResource resource = (IResource) item;
801: if (this .filterContainer.findMember(resource.getFullPath()) != null)
802: return true;
803: return false;
804: }
805:
806: /**
807: * @param item
808: * Must be instance of IResource, otherwise
809: * <code>false</code> will be returned.
810: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter#matchItem(java.lang.Object)
811: */
812: public boolean matchItem(Object item) {
813: if (!(item instanceof IResource)) {
814: return false;
815: }
816: IResource resource = (IResource) item;
817: if ((!this .showDerived && resource.isDerived())
818: || ((this .filterTypeMask & resource.getType()) == 0))
819: return false;
820: return matches(resource.getName());
821: }
822:
823: /*
824: * (non-Javadoc)
825: *
826: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter#isSubFilter(org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter)
827: */
828: public boolean isSubFilter(ItemsFilter filter) {
829: if (!super .isSubFilter(filter))
830: return false;
831: if (filter instanceof ResourceFilter)
832: if (this .showDerived == ((ResourceFilter) filter).showDerived)
833: return true;
834: return false;
835: }
836:
837: /*
838: * (non-Javadoc)
839: *
840: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter#equalsFilter(org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.ItemsFilter)
841: */
842: public boolean equalsFilter(ItemsFilter iFilter) {
843: if (!super .equalsFilter(iFilter))
844: return false;
845: if (iFilter instanceof ResourceFilter)
846: if (this .showDerived == ((ResourceFilter) iFilter).showDerived)
847: return true;
848: return false;
849: }
850:
851: /**
852: * Check show derived flag for a filter
853: *
854: * @return true if filter allow derived resources false if not
855: */
856: public boolean isShowDerived() {
857: return showDerived;
858: }
859:
860: }
861:
862: /**
863: * <code>ResourceSelectionHistory</code> provides behavior specific to
864: * resources - storing and restoring <code>IResource</code>s state
865: * to/from XML (memento).
866: */
867: private class ResourceSelectionHistory extends SelectionHistory {
868:
869: /*
870: * (non-Javadoc)
871: *
872: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.SelectionHistory#restoreItemFromMemento(org.eclipse.ui.IMemento)
873: */
874: protected Object restoreItemFromMemento(IMemento element) {
875: ResourceFactory resourceFactory = new ResourceFactory();
876: IResource resource = (IResource) resourceFactory
877: .createElement(element);
878: return resource;
879: }
880:
881: /*
882: * (non-Javadoc)
883: *
884: * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.SelectionHistory#storeItemToMemento(java.lang.Object,
885: * org.eclipse.ui.IMemento)
886: */
887: protected void storeItemToMemento(Object item, IMemento element) {
888: IResource resource = (IResource) item;
889: ResourceFactory resourceFactory = new ResourceFactory(
890: resource);
891: resourceFactory.saveState(element);
892: }
893:
894: }
895:
896: }
|