From 505e2b59e19a064f0ccfed0ddd21e354e07f8e0a Mon Sep 17 00:00:00 2001 From: Alain Magloire Date: Thu, 20 Feb 2003 21:15:19 +0000 Subject: [PATCH] Support for Working set. --- core/org.eclipse.cdt.ui/ChangeLog | 19 +++ .../cview/AdjustWorkingSetFilterAction.java | 27 +++ .../eclipse/cdt/internal/ui/cview/CView.java | 157 +++++++++++++++++- .../internal/ui/cview/CWorkingSetFilter.java | 114 +++++++++++++ .../ui/cview/NewWorkingSetFilterAction.java | 55 ++++++ 5 files changed, 366 insertions(+), 6 deletions(-) create mode 100644 core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/AdjustWorkingSetFilterAction.java create mode 100644 core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CWorkingSetFilter.java create mode 100644 core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/NewWorkingSetFilterAction.java diff --git a/core/org.eclipse.cdt.ui/ChangeLog b/core/org.eclipse.cdt.ui/ChangeLog index 48039fc39f1..e99dfb1964a 100644 --- a/core/org.eclipse.cdt.ui/ChangeLog +++ b/core/org.eclipse.cdt.ui/ChangeLog @@ -1,3 +1,22 @@ +2003-02-20 Alain Magloire + + This patch provides the UI controls and filters to use the working set + concept and apply it to the CView. The UI mimics the behaviour of what is + used by the Java packages view (rather than incorporating it as a part of + the Filters... dialog as was done in the Navigator). I didn't create a + specific C/C++ Working Set type since I figured that for C and C++ + projects which might include other projects it wasn't required. + This can be re-examined at a later date if required. + + * src/org/eclipse/cdt/internal/ui/cview/CView.java: + Listener of the property change for Working sets. + * src/org/eclipse/cdt/internal/ui/cview/AdjustWorkingSetFilterAction.java: + New file. + * src/org/eclipse/cdt/internal/ui/cview/CWorkingSetFilter.java: + New file. + * src/org/eclipse/cdt/internal/ui/cview/NewWorkingSetFilterAction.java: + New file. + 2003-02 -20 David Inglis * src/org/eclipse/cdt/internal/ui/editor/CEditorActionContributor.java diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/AdjustWorkingSetFilterAction.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/AdjustWorkingSetFilterAction.java new file mode 100644 index 00000000000..256192f8803 --- /dev/null +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/AdjustWorkingSetFilterAction.java @@ -0,0 +1,27 @@ +package org.eclipse.cdt.internal.ui.cview; + +import org.eclipse.jface.action.Action; + +/** + * @author ThomasF + * + * Set a manager with a specific filter type/working set + */ +public class AdjustWorkingSetFilterAction extends Action { + CWorkingSetFilter fFilter; + String fName; + + public AdjustWorkingSetFilterAction(String name, String setName, CWorkingSetFilter filter) { + super(name); + fName = setName; + fFilter = filter; + } + + public void run() { + if(fFilter == null) { + return; + } + + fFilter.setWorkingSetName(fName); + } +} diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CView.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CView.java index ca8845c86a2..346376d422f 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CView.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CView.java @@ -40,6 +40,9 @@ import org.eclipse.core.resources.IncrementalProjectBuilder; import org.eclipse.core.runtime.IAdaptable; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.ActionContributionItem; +import org.eclipse.jface.action.GroupMarker; import org.eclipse.jface.action.IMenuListener; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.IToolBarManager; @@ -85,6 +88,8 @@ import org.eclipse.ui.IViewSite; import org.eclipse.ui.IWorkbenchActionConstants; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.IWorkingSet; +import org.eclipse.ui.IWorkingSetManager; import org.eclipse.ui.PartInitException; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.actions.AddBookmarkAction; @@ -147,6 +152,9 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge ForwardAction forwardAction; GoIntoAction goIntoAction; UpAction upAction; + NewWorkingSetFilterAction wsFilterAction; + AdjustWorkingSetFilterAction wsClearFilterAction; + FrameList frameList; CViewFrameSource frameSource; @@ -156,6 +164,8 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge CLibFilter clibFilter = new CLibFilter (); ShowLibrariesAction clibFilterAction; + CWorkingSetFilter workingSetFilter = new CWorkingSetFilter (); + ActionContributionItem adjustWorkingSetContributions [] = new ActionContributionItem[5]; // Persistance tags. static final String TAG_SELECTION= "selection"; //$NON-NLS-1$ @@ -167,6 +177,11 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge static final String TAG_FILTERS = "filters"; //$NON-NLS-1$ static final String TAG_FILTER = "filter"; //$NON-NLS-1$ static final String TAG_SHOWLIBRARIES = "showLibraries"; //$NON-NLS-1$ + static final String TAG_WORKINGSET = "workingSet"; //$NON-NLS-1$ + + //Menu tags + final String WORKING_GROUP_MARKER = "workingSetGroup"; + final String WORKING_GROUP_MARKER_END = "end-workingSetGroup"; private IPartListener partListener = new IPartListener() { public void partActivated(IWorkbenchPart part) { @@ -179,8 +194,46 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge public void partDeactivated(IWorkbenchPart part) {} public void partOpened(IWorkbenchPart part) {} }; + + private IPropertyChangeListener workingSetListener = new IPropertyChangeListener() { + public void propertyChange(PropertyChangeEvent ev) { + String prop = ev.getProperty(); + if(prop == null) { + return; + } - + if(prop.equals(CWorkingSetFilter.WORKING_SET_ACTIVE_CHANGED)) { + updateWorkingSetMenu(); + viewer.getControl().setRedraw(false); + viewer.refresh(); + viewer.getControl().setRedraw(true); + } else if(prop.equals(IWorkingSetManager.CHANGE_WORKING_SET_ADD)) { + updateWorkingSetMenu(); + } else if(prop.equals(IWorkingSetManager.CHANGE_WORKING_SET_NAME_CHANGE)) { + updateWorkingSetMenu(); + } else if(prop.equals(IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE)){ + if(ev.getOldValue() instanceof IWorkingSet) { + String name = ((IWorkingSet)(ev.getOldValue())).getName(); + String wsName = workingSetFilter.getWorkingSetName(); + if(wsName != null && name.equals(wsName)) { + viewer.getControl().setRedraw(false); + viewer.refresh(); + viewer.getControl().setRedraw(true); + } + } + } else if(prop.equals(IWorkingSetManager.CHANGE_WORKING_SET_REMOVE)) { + if(ev.getOldValue() instanceof IWorkingSet) { + String name = ((IWorkingSet)(ev.getOldValue())).getName(); + String wsName = workingSetFilter.getWorkingSetName(); + if(wsName != null && name.equals(wsName)) { + workingSetFilter.setWorkingSetName(null); + } + } + updateWorkingSetMenu(); + } + } + }; + public CView() { super(); } @@ -375,12 +428,17 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge CUIPlugin.getDefault().getProblemMarkerManager().addListener(viewer); CUIPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(this); + IWorkingSetManager wsmanager = getViewSite().getWorkbenchWindow().getWorkbench().getWorkingSetManager(); + workingSetFilter.setWorkingSetManager(wsmanager); + + // FIXME: Add Drag and Drop support. initFrameList(); initRefreshKey(); updateTitle(); initDragAndDrop(); viewer.addFilter(patternFilter); + viewer.addFilter(workingSetFilter); //viewer.addFilter(clibFilter); viewer.setSorter(new CViewSorter ()); // FIXME: Add different Sorting. @@ -402,6 +460,10 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge // Make the Actions for the Context Menu makeActions(); + //Add the property changes after all of the UI work has been done. + wsmanager.addPropertyChangeListener(workingSetListener); + workingSetFilter.addChangeListener(workingSetListener); + viewer.addDoubleClickListener(new IDoubleClickListener() { public void doubleClick(DoubleClickEvent event) { handleDoubleClick(event); @@ -447,6 +509,10 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge IWorkspace workspace = CUIPlugin.getWorkspace(); workspace.removeResourceChangeListener(closeProjectAction); workspace.removeResourceChangeListener(openProjectAction); + + IWorkingSetManager wsmanager = getViewSite().getWorkbenchWindow().getWorkbench().getWorkingSetManager(); + wsmanager.removePropertyChangeListener(workingSetListener); + super.dispose(); } @@ -478,14 +544,21 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge return clibFilter; } - /** - * Returns the pattern filter for this view. - * @return the pattern filter - */ + /** + * Returns the pattern filter for this view. + * @return the pattern filter + */ CPatternFilter getPatternFilter() { return patternFilter; } - + + /** + * Returns the working set filter for this view. + * @return the working set filter + */ + CWorkingSetFilter getWorkingSetFilter() { + return workingSetFilter; + } TreeViewer getViewer () { return viewer; @@ -522,6 +595,9 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge patternFilterAction = new FilterSelectionAction(shell, this, "Filters..."); clibFilterAction = new ShowLibrariesAction(shell, this, "Show Referenced Libs"); + wsFilterAction = new NewWorkingSetFilterAction(getViewSite().getShell(), this, "Select Working Set..."); + wsClearFilterAction = new AdjustWorkingSetFilterAction("Deselect Working Set", null, workingSetFilter); + goIntoAction = new GoIntoAction(frameList); backAction = new BackAction(frameList); forwardAction = new ForwardAction(frameList); @@ -955,9 +1031,63 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge actionBars.updateActionBars(); IMenuManager menu = actionBars.getMenuManager(); + menu.add(wsFilterAction); + menu.add(wsClearFilterAction); + + menu.add(new Separator()); + menu.add(new GroupMarker(WORKING_GROUP_MARKER)); + menu.add(new GroupMarker(WORKING_GROUP_MARKER_END)); + menu.add(new Separator()); + + updateWorkingSetMenu(); + //menu.add (clibFilterAction); menu.add (patternFilterAction); } + + void updateWorkingSetMenu() { + IMenuManager menu = getViewSite().getActionBars().getMenuManager(); + + //Remove the previous entries + for(int i = 0; i < adjustWorkingSetContributions.length; i++) { + if(adjustWorkingSetContributions[i] != null) { + menu.remove(adjustWorkingSetContributions[i]); + } + } + + //Find out what we are currently using + String currentWorkingSetName = workingSetFilter.getWorkingSetName(); + + //If we have no working set, then we can't disable it + if(wsClearFilterAction != null) { + wsClearFilterAction.setEnabled((currentWorkingSetName != null)); + } + + IWorkingSetManager manager = getViewSite().getWorkbenchWindow().getWorkbench().getWorkingSetManager(); + IWorkingSet recentsets [] = manager.getWorkingSets(); + for(int i = 0; i < adjustWorkingSetContributions.length; i++) { + if(i < recentsets.length) { + Action action = new AdjustWorkingSetFilterAction(recentsets[i].getName(), + recentsets[i].getName(), + workingSetFilter); + adjustWorkingSetContributions[i] = new ActionContributionItem(action); + if(currentWorkingSetName != null && + currentWorkingSetName.equals(recentsets[i].getName())) { + adjustWorkingSetContributions[i].getAction().setChecked(true); + } + } else { + adjustWorkingSetContributions[i] = null; + } + } + + //Put the new entries in + for(int i = 0; i < adjustWorkingSetContributions.length; i++) { + if(adjustWorkingSetContributions[i] != null) { + menu.appendToGroup(WORKING_GROUP_MARKER, adjustWorkingSetContributions[i]); + } + } + } + /** * Sets the decorator for the package explorer. @@ -1058,6 +1188,15 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge } else initFilterFromPreferences(); + + //restore working set + String wsname = memento.getString(TAG_WORKINGSET); + if(wsname != null && workingSetFilter != null) { + IWorkingSet set = getViewSite().getWorkbenchWindow().getWorkbench().getWorkingSetManager().getWorkingSet(wsname); + if(set != null) { + workingSetFilter.setWorkingSetName(wsname); + } + } } void restoreState(IMemento memento) { @@ -1177,11 +1316,17 @@ public class CView extends ViewPart implements IMenuListener, ISetSelectionTarge child.putString(TAG_ELEMENT,filters[i]); } } + //save library filter boolean showLibraries= getLibraryFilter().getShowLibraries(); String show= "true"; //$NON-NLS-1$ if (!showLibraries) show= "false"; //$NON-NLS-1$ memento.putString(TAG_SHOWLIBRARIES, show); + + String wsname = workingSetFilter.getWorkingSetName(); + if(wsname != null) { + memento.putString(TAG_WORKINGSET, wsname); + } } } diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CWorkingSetFilter.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CWorkingSetFilter.java new file mode 100644 index 00000000000..088f8751d05 --- /dev/null +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/CWorkingSetFilter.java @@ -0,0 +1,114 @@ +package org.eclipse.cdt.internal.ui.cview; + +/* + * (c) Copyright QNX Software Systems Ltd. 2002. + * All Rights Reserved. + */ + +import java.util.ArrayList; + +import org.eclipse.cdt.ui.CUIPlugin; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.jface.util.IPropertyChangeListener; +import org.eclipse.jface.util.PropertyChangeEvent; +import org.eclipse.jface.viewers.Viewer; +import org.eclipse.jface.viewers.ViewerFilter; +import org.eclipse.ui.IWorkingSet; +import org.eclipse.ui.IWorkingSetManager; + +public class CWorkingSetFilter extends ViewerFilter { + public static final String WORKING_SET_ACTIVE_CHANGED = CUIPlugin.getPluginId() + ".ACTIVE_CHANGED"; + + private IWorkingSetManager fWorkingSetManager; + private IWorkingSet fWorkingSet; + private String fWorkingSetName; + private ArrayList fListeners; + + public CWorkingSetFilter() { + this(null); + } + + public CWorkingSetFilter(IWorkingSetManager manager) { + fWorkingSetManager = manager; + fWorkingSet = null; + fListeners = new ArrayList(1); + } + + public void setWorkingSetManager(IWorkingSetManager manager) { + fWorkingSetManager = manager; + } + + public void setWorkingSetName(String name) { + fWorkingSetName = name; + if(name == null) { + fWorkingSet = null; + notifyChange(); + return; + } + + if(fWorkingSetManager != null) { + fWorkingSet = fWorkingSetManager.getWorkingSet(fWorkingSetName); + } else { + fWorkingSet = null; + } + + notifyChange(); + } + + public String getWorkingSetName() { + return fWorkingSetName; + } + + public void addChangeListener(IPropertyChangeListener listener) { + fListeners.remove(listener); + fListeners.add(listener); + } + + public void removeChangeListener(IPropertyChangeListener listener) { + fListeners.remove(listener); + } + + private void notifyChange() { + PropertyChangeEvent ev = new PropertyChangeEvent(this, WORKING_SET_ACTIVE_CHANGED, null, null); + for(int i = 0; i < fListeners.size(); i++) { + IPropertyChangeListener l = (IPropertyChangeListener)fListeners.get(i); + l.propertyChange(ev); + } + } + + /* (non-Javadoc) + * Method declared on ViewerFilter. + */ + public boolean select(Viewer viewer, Object parentElement, Object element) { + //No filter set, everything allowed + if(fWorkingSet == null) { + return true; + } + + IResource resource = null; + if (element instanceof IResource) { + resource = (IResource) element; + } else if (element instanceof IAdaptable) { + IAdaptable adaptable = (IAdaptable) element; + resource = (IResource) adaptable.getAdapter(IResource.class); + } + + //We only filter projects out (should this be ICProjects?) + if(!(resource instanceof IProject)) { + return true; + } + + //Run our list to see if we are included in this working set + IAdaptable [] adaptables = fWorkingSet.getElements(); + for(int i = 0; i < adaptables.length; i++) { + if(adaptables[i].equals(resource)) { + return true; + } + } + + //Not in the working set, so we aren't shown + return false; + } +} diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/NewWorkingSetFilterAction.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/NewWorkingSetFilterAction.java new file mode 100644 index 00000000000..ad78eb08a83 --- /dev/null +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/cview/NewWorkingSetFilterAction.java @@ -0,0 +1,55 @@ +package org.eclipse.cdt.internal.ui.cview; + +import org.eclipse.jface.action.Action; +import org.eclipse.jface.viewers.TreeViewer; +import org.eclipse.jface.window.Window; +import org.eclipse.swt.widgets.Shell; +import org.eclipse.ui.IWorkingSet; +import org.eclipse.ui.IWorkingSetManager; +import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog; + +/** + * @author ThomasF + * + * This action is specifically designed to invoke the working set selection + * dialog to allow the user to select/edit a working set. + */ +public class NewWorkingSetFilterAction extends Action { + CView cview; + Shell shell; + + public NewWorkingSetFilterAction(Shell shell, CView cview, String label) { + super(label); + this.cview = cview; + this.shell = shell; + } + + public void run() { + if(cview == null || shell == null) { + return; + } + + IWorkingSetManager wsmanager = cview.getViewSite().getWorkbenchWindow().getWorkbench().getWorkingSetManager(); + IWorkingSetSelectionDialog dialog; + dialog = wsmanager.createWorkingSetSelectionDialog(shell, false); + if(dialog.open() == Window.CANCEL) { + return; + } + + IWorkingSet [] selection = dialog.getSelection(); + if(selection.length != 0) { + CWorkingSetFilter filter = cview.getWorkingSetFilter(); + if(filter == null) { + return; + } + + filter.setWorkingSetName(selection[0].getName()); + + TreeViewer viewer= cview.getViewer(); + viewer.getControl().setRedraw(false); + viewer.refresh(); + viewer.getControl().setRedraw(true); + } + } + +}