Improve setup related models

5 files changed, 305 insertions, 98 deletions

diff --git a/plugins/org.eclipse.emf.cdo.releng.setup/src/org/eclipse/emf/cdo/releng/setup/impl/ResourceCopyTaskImpl.java b/plugins/org.eclipse.emf.cdo.releng.setup/src/org/eclipse/emf/cdo/releng/setup/impl/ResourceCopyTaskImpl.java
index 4a4d7c89c8..10c9f95420 100644
--- a/plugins/org.eclipse.emf.cdo.releng.setup/src/org/eclipse/emf/cdo/releng/setup/impl/ResourceCopyTaskImpl.java
+++ b/plugins/org.eclipse.emf.cdo.releng.setup/src/org/eclipse/emf/cdo/releng/setup/impl/ResourceCopyTaskImpl.java
@@ -122,8 +122,10 @@ public class ResourceCopyTaskImpl extends SetupTaskImpl implements ResourceCopyT
     String oldSourceURL = sourceURL;
     sourceURL = newSourceURL;
     if (eNotificationRequired())
+    {
       eNotify(new ENotificationImpl(this, Notification.SET, SetupPackage.RESOURCE_COPY_TASK__SOURCE_URL, oldSourceURL,
           sourceURL));
+    }
   }
 
   /**
@@ -146,8 +148,10 @@ public class ResourceCopyTaskImpl extends SetupTaskImpl implements ResourceCopyT
     String oldTargetURL = targetURL;
     targetURL = newTargetURL;
     if (eNotificationRequired())
+    {
       eNotify(new ENotificationImpl(this, Notification.SET, SetupPackage.RESOURCE_COPY_TASK__TARGET_URL, oldTargetURL,
           targetURL));
+    }
   }
 
   /**
@@ -235,7 +239,9 @@ public class ResourceCopyTaskImpl extends SetupTaskImpl implements ResourceCopyT
   public String toString()
   {
     if (eIsProxy())
+    {
       return super.toString();
+    }
 
     StringBuffer result = new StringBuffer(super.toString());
     result.append(" (sourceURL: ");
@@ -273,6 +279,9 @@ public class ResourceCopyTaskImpl extends SetupTaskImpl implements ResourceCopyT
   {
     URI sourceURI = URI.createURI(context.expandString(getSourceURL()));
     URI targetURI = URI.createURI(context.expandString(getTargetURL()));
+
+    context.log("Copying " + sourceURI + " to " + targetURI);
+
     if (targetURI.hasTrailingPathSeparator())
     {
       if (sourceURI.hasTrailingPathSeparator())
diff --git a/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/ExclusionPredicateItemProvider.java b/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/ExclusionPredicateItemProvider.java
index 576109dd6f..e3dfc6d4cb 100644
--- a/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/ExclusionPredicateItemProvider.java
+++ b/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/ExclusionPredicateItemProvider.java
@@ -25,6 +25,7 @@ import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
 import org.eclipse.emf.edit.provider.ItemProviderAdapter;
 import org.eclipse.emf.edit.provider.ViewerNotification;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -209,8 +210,18 @@ public class ExclusionPredicateItemProvider extends ItemProviderAdapter implemen
   {
     if (commandParameter.getFeature() == null)
     {
-      return new AddCommand(domain, commandParameter.getEOwner(),
-          WorkingSetsPackage.Literals.EXCLUSION_PREDICATE__EXCLUDED_WORKING_SETS, commandParameter.getCollection());
+      EObject eOwner = commandParameter.getEOwner();
+      Collection<?> collection = commandParameter.getCollection();
+      if (collection != null)
+      {
+        collection = new ArrayList<Object>(collection);
+        filterCircularWorkingSets(eOwner, collection);
+        if (collection.size() == commandParameter.getCollection().size())
+        {
+          return new AddCommand(domain, eOwner, WorkingSetsPackage.Literals.EXCLUSION_PREDICATE__EXCLUDED_WORKING_SETS,
+              collection);
+        }
+      }
     }
 
     return super.factorAddCommand(domain, commandParameter);
diff --git a/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/InclusionPredicateItemProvider.java b/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/InclusionPredicateItemProvider.java
index b9e8e7c080..1ccfac85d9 100644
--- a/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/InclusionPredicateItemProvider.java
+++ b/plugins/org.eclipse.emf.cdo.releng.workingsets.edit/src/org/eclipse/emf/cdo/releng/workingsets/provider/InclusionPredicateItemProvider.java
@@ -25,6 +25,7 @@ import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
 import org.eclipse.emf.edit.provider.ItemProviderAdapter;
 import org.eclipse.emf.edit.provider.ViewerNotification;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
@@ -162,8 +163,18 @@ public class InclusionPredicateItemProvider extends ItemProviderAdapter implemen
   {
     if (commandParameter.getFeature() == null)
     {
-      return new AddCommand(domain, commandParameter.getEOwner(),
-          WorkingSetsPackage.Literals.INCLUSION_PREDICATE__INCLUDED_WORKING_SETS, commandParameter.getCollection());
+      EObject eOwner = commandParameter.getEOwner();
+      Collection<?> collection = commandParameter.getCollection();
+      if (collection != null)
+      {
+        collection = new ArrayList<Object>(collection);
+        ExclusionPredicateItemProvider.filterCircularWorkingSets(eOwner, collection);
+        if (collection.size() == commandParameter.getCollection().size())
+        {
+          return new AddCommand(domain, commandParameter.getEOwner(),
+              WorkingSetsPackage.Literals.INCLUSION_PREDICATE__INCLUDED_WORKING_SETS, commandParameter.getCollection());
+        }
+      }
     }
 
     return super.factorAddCommand(domain, commandParameter);
diff --git a/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetManager.java b/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetManager.java
index bcad632032..cb7247f450 100644
--- a/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetManager.java
+++ b/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetManager.java
@@ -31,6 +31,10 @@ import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
 import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.IAggregateWorkingSet;
+import org.eclipse.ui.IPageLayout;
+import org.eclipse.ui.IPerspectiveDescriptor;
+import org.eclipse.ui.IPerspectiveListener;
 import org.eclipse.ui.IViewPart;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchWindow;
@@ -38,6 +42,7 @@ import org.eclipse.ui.IWorkingSet;
 import org.eclipse.ui.IWorkingSetManager;
 import org.eclipse.ui.PlatformUI;
 
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -89,8 +94,11 @@ public class WorkingSetManager
         }
 
         // Update the working sets for all the projects in the workspace and apply the result to the real working sets.
-        updateProjects(workingSets);
-        apply(workingSets);
+        if (!workingSets.isEmpty())
+        {
+          updateProjects(workingSets);
+          apply(workingSets);
+        }
       }
     }
   };
@@ -99,47 +107,80 @@ public class WorkingSetManager
   {
     public void resourceChanged(IResourceChangeEvent event)
     {
-      IResourceDelta delta = event.getDelta();
-      if (delta != null)
+      if (!workingSetGroup.getWorkingSets().isEmpty())
       {
-        try
+        IResourceDelta delta = event.getDelta();
+        if (delta != null)
         {
-          // Compute the workings sets and update them relative to our workspace delta, i.e., relative to added and
-          // removed projects.
-          final EMap<String, Set<IAdaptable>> workingSets = getWorkingSets();
-          IResourceDeltaVisitor resourceDeltaVisitor = new IResourceDeltaVisitor()
+          try
           {
-            public boolean visit(IResourceDelta delta) throws CoreException
+            // Compute the workings sets and update them relative to our workspace delta, i.e., relative to added and
+            // removed projects.
+            class ResourceDeltaVisitor implements IResourceDeltaVisitor
             {
-              IResource resource = delta.getResource();
-              if (resource instanceof IWorkspaceRoot)
-              {
-                return true;
-              }
+              public boolean isChanged;
 
-              if (resource instanceof IProject)
+              public EMap<String, Set<IAdaptable>> workingSets = null;
+
+              public boolean visit(IResourceDelta delta) throws CoreException
               {
-                int kind = delta.getKind();
-                if (kind == IResourceDelta.ADDED)
+                IResource resource = delta.getResource();
+                if (resource instanceof IWorkspaceRoot)
                 {
-                  addProject((IProject)resource, workingSets);
+                  return true;
                 }
-                else if (kind == IResourceDelta.REMOVED)
+
+                if (resource instanceof IProject)
                 {
-                  removeProject((IProject)resource, workingSets);
+                  int kind = delta.getKind();
+                  if (kind == IResourceDelta.ADDED)
+                  {
+                    IProject project = (IProject)resource;
+                    if (!project.isHidden())
+                    {
+                      if (workingSets == null)
+                      {
+                        workingSets = getWorkingSets();
+                      }
+                      if (addProject(project, workingSets))
+                      {
+                        isChanged = true;
+                      }
+                    }
+                  }
+                  else if (kind == IResourceDelta.REMOVED)
+                  {
+                    IProject project = (IProject)resource;
+                    if (!project.isHidden())
+                    {
+                      if (workingSets == null)
+                      {
+                        workingSets = getWorkingSets();
+                      }
+                      if (removeProject(project, workingSets))
+                      {
+                        isChanged = true;
+                      }
+                    }
+                  }
                 }
-              }
 
-              return false;
+                return false;
+              }
             }
-          };
 
-          delta.accept(resourceDeltaVisitor);
-          apply(workingSets);
-        }
-        catch (CoreException ex)
-        {
-          // Ignore
+            ResourceDeltaVisitor resourceDeltaVisitor = new ResourceDeltaVisitor();
+
+            delta.accept(resourceDeltaVisitor);
+            if (resourceDeltaVisitor.isChanged)
+            {
+              apply(resourceDeltaVisitor.workingSets);
+            }
+          }
+          catch (CoreException ex)
+          {
+            // Ignore
+          }
         }
       }
     }
@@ -222,92 +263,144 @@ public class WorkingSetManager
           }
         }
 
-        managePackageExplorer();
+        managePackageExplorer(true);
       }
     });
   }
 
-  private void managePackageExplorer()
+  private void managePackageExplorer(boolean addListener)
   {
     try
     {
+      boolean handledNavigator = false;
+      boolean handledPackageExplorer = false;
+
       for (IWorkbenchWindow workbenchWindow : PlatformUI.getWorkbench().getWorkbenchWindows())
       {
         for (IWorkbenchPage workbenchPage : workbenchWindow.getPages())
         {
-          IViewPart view = workbenchPage.findView(PACKAGE_EXPLORER_ID);
-          if (view != null)
+          if (!handledNavigator)
           {
-            Method getWorkingSetModelMethod = view.getClass().getMethod("getWorkingSetModel");
-            Object workingSetModel = getWorkingSetModelMethod.invoke(view);
-            if (workingSetModel != null)
+            Object commonNavigator = workbenchPage.findView(IPageLayout.ID_PROJECT_EXPLORER);
+            if (commonNavigator != null)
             {
-              Class<?> workingSetModelClass = workingSetModel.getClass();
-              Method getAllWorkingSetsMethod = workingSetModelClass.getMethod("getAllWorkingSets");
-              IWorkingSet[] allWorkingSets = (IWorkingSet[])getAllWorkingSetsMethod.invoke(workingSetModel);
-
-              Map<WorkingSet, IWorkingSet> managedWorkingSets = new HashMap<WorkingSet, IWorkingSet>();
-              for (int i = 0; i < allWorkingSets.length; ++i)
+              handledNavigator = true;
+
+              Method getNavigatorActionServiceMethod = commonNavigator.getClass()
+                  .getMethod("getNavigatorActionService");
+              Object navigatorActionService = getNavigatorActionServiceMethod.invoke(commonNavigator);
+              Field actionProviderInstancesField = navigatorActionService.getClass().getDeclaredField(
+                  "actionProviderInstances");
+              actionProviderInstancesField.setAccessible(true);
+              HashMap<?, ?> object = (HashMap<?, ?>)actionProviderInstancesField.get(navigatorActionService);
+              if (object != null)
               {
-                IWorkingSet iWorkingSet = allWorkingSets[i];
-                WorkingSet workingSet = workingSetGroup.getWorkingSet(iWorkingSet.getName());
-                if (workingSet != null)
+                for (Object value : object.values())
                 {
-                  managedWorkingSets.put(workingSet, iWorkingSet);
+                  Class<? extends Object> theClass = value.getClass();
+                  if ("org.eclipse.ui.internal.navigator.resources.actions.WorkingSetActionProvider".equals(theClass
+                      .getName()))
+                  {
+
+                    Field workingSetField = theClass.getDeclaredField("workingSet");
+                    workingSetField.setAccessible(true);
+                    IWorkingSet oldWorkingSet = (IWorkingSet)workingSetField.get(value);
+
+                    IWorkingSet[] activeWorkingSets = oldWorkingSet == null ? new IWorkingSet[0] : oldWorkingSet
+                        .isAggregateWorkingSet() ? ((IAggregateWorkingSet)oldWorkingSet).getComponents()
+                        : new IWorkingSet[] { oldWorkingSet };
+
+                    Set<IWorkingSet> allWorkingSets = new LinkedHashSet<IWorkingSet>(Arrays.asList(activeWorkingSets));
+                    allWorkingSets.addAll(Arrays.asList(MANAGER.getAllWorkingSets()));
+
+                    List<IWorkingSet> newActiveWorkingSets = getActiveWorkingSets(
+                        allWorkingSets.toArray(new IWorkingSet[allWorkingSets.size()]), activeWorkingSets);
+                    StringBuilder id = new StringBuilder("Aggregate:");
+                    for (IWorkingSet iWorkingSet : newActiveWorkingSets)
+                    {
+                      id.append(iWorkingSet.getName());
+                      id.append(":");
+                    }
+
+                    IWorkingSet aggregateWorkingSet = MANAGER.getWorkingSet(id.toString());
+                    if (aggregateWorkingSet == null)
+                    {
+                      aggregateWorkingSet = MANAGER.createAggregateWorkingSet(id.toString(), "Multiple Working Sets",
+                          newActiveWorkingSets.toArray(new IWorkingSet[newActiveWorkingSets.size()]));
+                      MANAGER.addWorkingSet(aggregateWorkingSet);
+                    }
+                    MANAGER.addRecentWorkingSet(aggregateWorkingSet);
+
+                    Method setWorkingSetMethod = theClass.getDeclaredMethod("setWorkingSet", IWorkingSet.class);
+                    setWorkingSetMethod.setAccessible(true);
+                    setWorkingSetMethod.invoke(value, aggregateWorkingSet);
+                  }
                 }
               }
+            }
+          }
 
-              Map<IWorkingSet, List<IWorkingSet>> orderedWorkingSetGroups = new LinkedHashMap<IWorkingSet, List<IWorkingSet>>();
-              for (WorkingSet workingSet : workingSetGroup.getWorkingSets())
-              {
-                IWorkingSet iWorkingSet = managedWorkingSets.get(workingSet);
-                List<IWorkingSet> group = new ArrayList<IWorkingSet>();
-                group.add(iWorkingSet);
-                orderedWorkingSetGroups.put(iWorkingSet, group);
-              }
-
-              Method getActiveWorkingSetsMethod = workingSetModelClass.getMethod("getActiveWorkingSets");
-              List<IWorkingSet> activeWorkingSets = Arrays.asList((IWorkingSet[])getActiveWorkingSetsMethod
-                  .invoke(workingSetModel));
+          if (!handledPackageExplorer)
+          {
+            IViewPart packageExplorer = workbenchPage.findView(PACKAGE_EXPLORER_ID);
+            if (packageExplorer != null)
+            {
+              handledPackageExplorer = true;
 
-              List<IWorkingSet> newActiveWorkingSets = new ArrayList<IWorkingSet>();
-              List<IWorkingSet> group = newActiveWorkingSets;
-              for (IWorkingSet iWorkingSet : activeWorkingSets)
+              Method getWorkingSetModelMethod = packageExplorer.getClass().getMethod("getWorkingSetModel");
+              Object workingSetModel = getWorkingSetModelMethod.invoke(packageExplorer);
+              if (workingSetModel != null)
               {
-                List<IWorkingSet> targetGroup = orderedWorkingSetGroups.get(iWorkingSet);
-                if (targetGroup == null)
-                {
-                  group.add(iWorkingSet);
-                }
-                else
-                {
-                  group = targetGroup;
-                }
-              }
+                Class<?> workingSetModelClass = workingSetModel.getClass();
+                Method getAllWorkingSetsMethod = workingSetModelClass.getMethod("getAllWorkingSets");
+                IWorkingSet[] allWorkingSets = (IWorkingSet[])getAllWorkingSetsMethod.invoke(workingSetModel);
 
-              for (List<IWorkingSet> workingSets : orderedWorkingSetGroups.values())
-              {
-                newActiveWorkingSets.addAll(workingSets);
-              }
+                Method getActiveWorkingSetsMethod = workingSetModelClass.getMethod("getActiveWorkingSets");
+                IWorkingSet[] activeWorkingSets = (IWorkingSet[])getActiveWorkingSetsMethod.invoke(workingSetModel);
 
-              IWorkingSet[] orderedActiveWorkingSetsArray = newActiveWorkingSets
-                  .toArray(new IWorkingSet[newActiveWorkingSets.size()]);
+                List<IWorkingSet> newActiveWorkingSets = getActiveWorkingSets(allWorkingSets, activeWorkingSets);
 
-              Method setWorkingSetsMethod = workingSetModelClass.getMethod("setActiveWorkingSets", IWorkingSet[].class);
+                IWorkingSet[] orderedActiveWorkingSetsArray = newActiveWorkingSets
+                    .toArray(new IWorkingSet[newActiveWorkingSets.size()]);
 
-              setWorkingSetsMethod.invoke(workingSetModel, new Object[] { orderedActiveWorkingSetsArray });
+                Method setWorkingSetsMethod = workingSetModelClass.getMethod("setActiveWorkingSets",
+                    IWorkingSet[].class);
 
-              Method getRootModeMethod = view.getClass().getMethod("getRootMode");
-              if (!getRootModeMethod.invoke(view).equals(2))
-              {
-                Method method = view.getClass().getMethod("rootModeChanged", int.class);
-                method.invoke(view, 2);
+                setWorkingSetsMethod.invoke(workingSetModel, new Object[] { orderedActiveWorkingSetsArray });
+
+                Method getRootModeMethod = packageExplorer.getClass().getMethod("getRootMode");
+                if (!getRootModeMethod.invoke(packageExplorer).equals(2))
+                {
+                  Method method = packageExplorer.getClass().getMethod("rootModeChanged", int.class);
+                  method.invoke(packageExplorer, 2);
+                }
               }
             }
-            return;
           }
         }
       }
+
+      if (addListener && !handledNavigator && !handledPackageExplorer)
+      {
+        final IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
+        if (activeWorkbenchWindow != null)
+        {
+          IPerspectiveListener perspectiveListener = new IPerspectiveListener()
+          {
+            public void perspectiveChanged(IWorkbenchPage page, IPerspectiveDescriptor perspective, String changeId)
+            {
+            }
+
+            public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective)
+            {
+              activeWorkbenchWindow.removePerspectiveListener(this);
+              managePackageExplorer(false);
+            }
+          };
+
+          activeWorkbenchWindow.addPerspectiveListener(perspectiveListener);
+        }
+      }
     }
     catch (NoSuchMethodException ex)
     {
@@ -325,24 +418,80 @@ public class WorkingSetManager
     {
       WorkingSetsEditorPlugin.INSTANCE.log(ex);
     }
+    catch (NoSuchFieldException ex)
+    {
+      WorkingSetsEditorPlugin.INSTANCE.log(ex);
+    }
+  }
+
+  private List<IWorkingSet> getActiveWorkingSets(IWorkingSet[] allWorkingSets, IWorkingSet[] activeWorkingSets)
+  {
+    Map<WorkingSet, IWorkingSet> managedWorkingSets = new HashMap<WorkingSet, IWorkingSet>();
+    for (int i = 0; i < allWorkingSets.length; ++i)
+    {
+      IWorkingSet iWorkingSet = allWorkingSets[i];
+      WorkingSet workingSet = workingSetGroup.getWorkingSet(iWorkingSet.getName());
+      if (workingSet != null)
+      {
+        managedWorkingSets.put(workingSet, iWorkingSet);
+      }
+    }
+
+    Map<IWorkingSet, List<IWorkingSet>> orderedWorkingSetGroups = new LinkedHashMap<IWorkingSet, List<IWorkingSet>>();
+    for (WorkingSet workingSet : workingSetGroup.getWorkingSets())
+    {
+      IWorkingSet iWorkingSet = managedWorkingSets.get(workingSet);
+      List<IWorkingSet> group = new ArrayList<IWorkingSet>();
+      group.add(iWorkingSet);
+      orderedWorkingSetGroups.put(iWorkingSet, group);
+    }
+
+    List<IWorkingSet> newActiveWorkingSets = new ArrayList<IWorkingSet>();
+    List<IWorkingSet> group = newActiveWorkingSets;
+    for (IWorkingSet iWorkingSet : activeWorkingSets)
+    {
+      List<IWorkingSet> targetGroup = orderedWorkingSetGroups.get(iWorkingSet);
+      if (targetGroup == null)
+      {
+        group.add(iWorkingSet);
+      }
+      else
+      {
+        group = targetGroup;
+      }
+    }
+
+    for (List<IWorkingSet> workingSets : orderedWorkingSetGroups.values())
+    {
+      newActiveWorkingSets.addAll(workingSets);
+    }
+    return newActiveWorkingSets;
   }
 
   /**
    * Compute the elements for the working sets based on the projects in the workspace.
+   * Returns <code>true</code> only if a project was added to some working set.
    */
-  private void updateProjects(EMap<String, Set<IAdaptable>> workingSets)
+  private boolean updateProjects(EMap<String, Set<IAdaptable>> workingSets)
   {
+    boolean result = false;
     for (IProject project : WORKSPACE.getRoot().getProjects())
     {
-      addProject(project, workingSets);
+      if (addProject(project, workingSets))
+      {
+        result = true;
+      }
     }
+    return result;
   }
 
   /**
    * Adds the project to the appropriate working set entry, if applicable.
+   * Returns <code>true</code> only if the project was added to some working set.
    */
-  private void addProject(IProject project, EMap<String, Set<IAdaptable>> workingSets)
+  private boolean addProject(IProject project, EMap<String, Set<IAdaptable>> workingSets)
   {
+    boolean result = false;
     for (WorkingSet workingSet : workingSetGroup.getWorkingSets())
     {
       if (workingSet.matches(project))
@@ -356,15 +505,19 @@ public class WorkingSetManager
         }
 
         elements.add(project);
+        result = true;
       }
     }
+    return result;
   }
 
   /**
    * Removes the project from the appropriate working set entry.
+   * Returns <code>true</code> only if the project was removed to some working set.
    */
-  private void removeProject(IProject project, EMap<String, Set<IAdaptable>> workingSets)
+  private boolean removeProject(IProject project, EMap<String, Set<IAdaptable>> workingSets)
   {
+    boolean result = false;
     for (WorkingSet workingSet : workingSetGroup.getWorkingSets())
     {
       if (workingSet.matches(project))
@@ -374,8 +527,10 @@ public class WorkingSetManager
         if (elements != null)
         {
           elements.remove(name);
+          result = true;
         }
       }
     }
+    return result;
   }
 }
diff --git a/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetsActionBarContributor.java b/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetsActionBarContributor.java
index e27a95a712..bd119e1460 100644
--- a/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetsActionBarContributor.java
+++ b/plugins/org.eclipse.emf.cdo.releng.workingsets.editor/src/org/eclipse/emf/cdo/releng/workingsets/presentation/WorkingSetsActionBarContributor.java
@@ -12,6 +12,7 @@ package org.eclipse.emf.cdo.releng.workingsets.presentation;
 
 import org.eclipse.emf.cdo.releng.workingsets.WorkingSet;
 import org.eclipse.emf.cdo.releng.workingsets.WorkingSetGroup;
+import org.eclipse.emf.cdo.releng.workingsets.WorkingSetsFactory;
 import org.eclipse.emf.cdo.releng.workingsets.provider.WorkingSetsEditPlugin;
 
 import org.eclipse.emf.common.command.CommandStackListener;
@@ -79,7 +80,6 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.EventObject;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Set;
 
@@ -297,27 +297,48 @@ public class WorkingSetsActionBarContributor extends EditingDomainActionBarContr
           .getPlugin().getDialogSettings()));
       tree.setLabelProvider(labelProvider);
 
+      WorkingSet otherProjectsWorkingSet = WorkingSetsFactory.eINSTANCE.createWorkingSet();
+      otherProjectsWorkingSet.setName("Other Projects");
+      ItemProvider otherProjects = new WorkingSetPresentation(otherProjectsWorkingSet);
+      children.add(otherProjects);
+
       Resource resource = editingDomain.getResourceSet().getResources().get(0);
       WorkingSetGroup workingSetGroup = (WorkingSetGroup)resource.getContents().get(0);
 
       Set<IProject> projects = new LinkedHashSet<IProject>(Arrays.asList(ResourcesPlugin.getWorkspace().getRoot()
           .getProjects()));
+      Set<IProject> unmatchedProjects = new LinkedHashSet<IProject>(projects);
       for (WorkingSet workingSet : workingSetGroup.getWorkingSets())
       {
         ItemProvider child = new WorkingSetPresentation(workingSet);
         EList<Object> contents = child.getChildren();
-        for (Iterator<IProject> it = projects.iterator(); it.hasNext();)
+
+        for (IProject project : projects)
         {
-          IProject project = it.next();
-          if (workingSet.matches(project))
+          if (project.isHidden())
+          {
+            unmatchedProjects.remove(project);
+          }
+          else if (workingSet.matches(project))
           {
             ItemProvider childProject = new ProjectPresentation(project);
             contents.add(childProject);
+            unmatchedProjects.remove(project);
           }
         }
 
         children.add(child);
       }
+
+      if (!unmatchedProjects.isEmpty())
+      {
+        EList<Object> contents = otherProjects.getChildren();
+        for (IProject project : unmatchedProjects)
+        {
+          ItemProvider childProject = new ProjectPresentation(project);
+          contents.add(childProject);
+        }
+      }
     }
 
     @Override