diff --git a/org.eclipse.mylyn.java.ui/META-INF/MANIFEST.MF b/org.eclipse.mylyn.java.ui/META-INF/MANIFEST.MF
index c421119..e881ffd 100644
--- a/org.eclipse.mylyn.java.ui/META-INF/MANIFEST.MF
+++ b/org.eclipse.mylyn.java.ui/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: Mylar Java Plug-in
 Bundle-SymbolicName: org.eclipse.mylar.java; singleton:=true
-Bundle-Version: 0.4.1
+Bundle-Version: 0.4.2
 Bundle-Activator: org.eclipse.mylar.java.MylarJavaPlugin
 Bundle-Localization: plugin
 Require-Bundle: org.eclipse.ui,
@@ -30,7 +30,10 @@
  org.eclipse.mylar.core,
  org.eclipse.mylar.ide,
  org.eclipse.mylar.tasklist,
- org.eclipse.mylar.ui
+ org.eclipse.mylar.ui,
+ org.eclipse.team.ui,
+ org.eclipse.team.cvs.core,
+ org.eclipse.team.core
 Eclipse-AutoStart: true
 Bundle-Vendor: Eclipse.org
 Export-Package: org.eclipse.mylar.java,
diff --git a/org.eclipse.mylyn.java.ui/plugin.xml b/org.eclipse.mylyn.java.ui/plugin.xml
index 9945770..a75034d 100644
--- a/org.eclipse.mylyn.java.ui/plugin.xml
+++ b/org.eclipse.mylyn.java.ui/plugin.xml
@@ -27,7 +27,7 @@
 	<extension
          point="org.eclipse.debug.core.launchConfigurationTypes">
       <launchConfigurationType
-            name="Task Context Test"
+            name="Mylar Active Suite"
             delegate="org.eclipse.mylar.java.internal.junit.MylarJUnitLaunchConfiguration"
             modes="run, debug"
             id="org.eclipse.mylar.java.junit.launchconfig"
@@ -44,7 +44,7 @@
       </launchConfigurationType>
          <launchConfigurationType
             sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
-            name="Task Context Plug-in Test"
+            name="Mylar Active Plug-in Suite"
             sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"
             delegate="org.eclipse.mylar.java.internal.junit.MylarPdeJUnitLaunchConfiguration"
             modes="run, debug"
@@ -151,7 +151,7 @@
    </extension>
   
    <extension point="org.eclipse.ui.viewActions"> 
-	<viewContribution 
+		<viewContribution 
 		id="org.eclipse.mylar.java.explorer.contribution" 
    		targetID="org.eclipse.jdt.ui.PackageExplorer">
     	<action
@@ -165,14 +165,33 @@
            toolbarPath="mylar"
            tooltip="Apply Mylar"> 
   		</action> 
-    </viewContribution>
- <viewContribution
+      </viewContribution>
+ 	  <viewContribution
        id="org.eclipse.mylar.ui.views.active.search.contribution"
        targetID="org.eclipse.mylar.ui.views.active.search">
- </viewContribution> 
+ 		</viewContribution>
 	</extension>
 	
-  <extension point = "org.eclipse.ui.popupMenus">
+  <extension point="org.eclipse.ui.popupMenus">
+       <viewerContribution
+            id="org.eclipse.mylar.java.ui.viewerContribution"
+            targetID="org.eclipse.mylar.tasks.ui.views.TaskListView">
+        <action
+              class="org.eclipse.mylar.java.ui.actions.CompleteTaskWizardAction"
+              enablesFor="*"
+              icon="icons/elcl16/cvs_persp.gif"
+              id="org.eclipse.mylar.ui.clear.context"
+              label="Commit Task Context..."
+              menubarPath="context"
+              tooltip="Commit All ">
+           <enablement>
+              <or>
+                 <objectClass name="org.eclipse.mylar.tasklist.ITask"/>
+              </or>
+           </enablement>
+        </action>
+     </viewerContribution>
+     
      <objectContribution
         id="org.eclipse.mylar.ui.interest"
         objectClass="org.eclipse.jdt.core.IJavaElement">
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaProblemListener.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaProblemListener.java
index bdfe43d..0c6c390 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaProblemListener.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaProblemListener.java
@@ -34,18 +34,18 @@
             for (int i = 0; i < changedResources.length; i++) {
                 IResource resource = changedResources[i];
                 try {
+                    boolean hasError = false; 
                     IMarker[] markers = resource.findMarkers(
                             IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER,
                             true, IResource.DEPTH_INFINITE);
                     IJavaElement element = (IJavaElement)resource.getAdapter(IJavaElement.class);
-                    boolean hasError = false; 
                     for (int j = 0; j < markers.length; j++) {
                         if (markers[j] != null
                         	&& markers[j].getAttribute(IMarker.SEVERITY) != null
                         	&& markers[j].getAttribute(IMarker.SEVERITY).equals(IMarker.SEVERITY_ERROR)) {
                             hasError = true;
                         } 
-                    }
+                    } 
                     if (element != null && resource instanceof IFile && !resource.getFileExtension().equals("class")) {
                         if (!hasError) {
                             MylarPlugin.getContextManager().removeErrorPredictedInterest(element.getHandleIdentifier(), JavaStructureBridge.CONTENT_TYPE, true);
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaStructureBridge.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaStructureBridge.java
index 267f8a0..c93dd23 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaStructureBridge.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/JavaStructureBridge.java
@@ -25,6 +25,7 @@
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IImportDeclaration;
 import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaModelMarker;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IMember;
 import org.eclipse.jdt.core.IPackageFragment;
@@ -135,6 +136,27 @@
      * i.e. they're not IJavaElement(s).
      */
     public boolean canFilter(Object object) {
+    	if (object instanceof IJavaElement) {
+    		try {
+	    		IJavaElement element = (IJavaElement)object;
+	            IResource resource = element.getCorrespondingResource();
+	            boolean hasError = false; 
+	            if (resource != null) {
+		            IMarker[] markers = resource.findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, true, 2);
+		            for (int j = 0; j < markers.length; j++) {
+		                if (markers[j] != null
+		                	&& markers[j].getAttribute(IMarker.SEVERITY) != null
+		                	&& markers[j].getAttribute(IMarker.SEVERITY).equals(IMarker.SEVERITY_ERROR)) {
+		                    hasError = true;
+		                } 
+		            } 
+		            if (hasError) return false;
+	            }
+			} catch (CoreException e) {
+				// ignore
+			}
+    	}
+    	
         if (object instanceof ClassPathContainer.RequiredProjectWrapper) {
             return true;
         }
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/MylarJavaPlugin.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/MylarJavaPlugin.java
index 7d3334f..eef9d67 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/MylarJavaPlugin.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/MylarJavaPlugin.java
@@ -46,93 +46,105 @@
  * @author Mik Kersten
  */
 public class MylarJavaPlugin extends AbstractUIPlugin {
-	
+
 	private static MylarJavaPlugin plugin;
+
 	private ResourceBundle resourceBundle;
+
 	private JavaEditorTracker editorTracker;
-    
+
 	private PackageExplorerManager packageExplorerManager = new PackageExplorerManager();
+
 	private TypeHistoryManager typeHistoryManager = new TypeHistoryManager();
+
 	private LandmarkMarkerManager landmarkMarkerManager = new LandmarkMarkerManager();
+
 	private JavaProblemListener problemListener = new JavaProblemListener();
+
 	private JavaEditingMonitor javaEditingMonitor;
+
 	private InterestUpdateDeltaListener javaElementChangeListener = new InterestUpdateDeltaListener();
 
+	private MylarChangeSetManager changeSetManager = new MylarChangeSetManager();
+
 	public static final String PLUGIN_ID = "org.eclipse.mylar.java";
-    public static final String MYLAR_JAVA_EDITOR_ID = "org.eclipse.mylar.java.ui.editor.MylarCompilationUnitEditor";
-    public static final String PACKAGE_EXPLORER_AUTO_FILTER_ENABLE = "org.eclipse.mylar.java.ui.explorer.filter.auto.enable";
-    public static final String PREDICTED_INTEREST_ERRORS = "org.eclipse.mylar.java.interest.predicted.errors";
-    public static final String PACKAGE_EXPLORER_AUTO_EXPAND = "org.eclipse.mylar.java.explorer.auto.exapand";
-        
+
+	public static final String MYLAR_JAVA_EDITOR_ID = "org.eclipse.mylar.java.ui.editor.MylarCompilationUnitEditor";
+
+	public static final String PACKAGE_EXPLORER_AUTO_FILTER_ENABLE = "org.eclipse.mylar.java.ui.explorer.filter.auto.enable";
+
+	public static final String PREDICTED_INTEREST_ERRORS = "org.eclipse.mylar.java.interest.predicted.errors";
+
+	public static final String PACKAGE_EXPLORER_AUTO_EXPAND = "org.eclipse.mylar.java.explorer.auto.exapand";
+
 	public static ImageDescriptor EDGE_REF_JUNIT = getImageDescriptor("icons/elcl16/edge-ref-junit.gif");
-    
-	public static final String FIRST_USE = 
-		"<html><body bgcolor=\"#ffffff\">" +
-		"<p>If this is your first time using Mylar <b>make sure to watch the </b>\n" +
-		"<a target=\"_blank\" href=\"http://eclipse.org/mylar/doc/demo/mylar-demo-03.html\">\n" +
-		"<b>5 minute online flash demo</b></a>.</p><p>Mylar documentation is under \n" +
-		"Help-&gt;Help Contents.</p>" +
-		"</body></html>";
-	
+
+	public static final String FIRST_USE = "<html><body bgcolor=\"#ffffff\">" + "<p>If this is your first time using Mylar <b>make sure to watch the </b>\n"
+			+ "<a target=\"_blank\" href=\"http://eclipse.org/mylar/doc/demo/mylar-demo-03.html\">\n"
+			+ "<b>5 minute online flash demo</b></a>.</p><p>Mylar documentation is under \n" + "Help-&gt;Help Contents.</p>" + "</body></html>";
+
 	public MylarJavaPlugin() {
 		super();
 		plugin = this;
-    }
+	}
 
 	/**
 	 * Startup order is critical.
 	 */
-    @Override
+	@Override
 	public void start(BundleContext context) throws Exception {
-		super.start(context);		
-        MylarPlugin.getContextManager().addListener(packageExplorerManager);
-        MylarPlugin.getContextManager().addListener(typeHistoryManager);
-        MylarPlugin.getContextManager().addListener(landmarkMarkerManager);
-		
-        setPreferenceDefaults();
-		if (getPreferenceStore().getBoolean(PREDICTED_INTEREST_ERRORS)) {
-			problemListener.enable();
+		try {
+			super.start(context);
+			MylarPlugin.getContextManager().addListener(packageExplorerManager);
+			MylarPlugin.getContextManager().addListener(typeHistoryManager);
+			MylarPlugin.getContextManager().addListener(landmarkMarkerManager);
+			MylarPlugin.getContextManager().addListener(changeSetManager);
+
+			setPreferenceDefaults();
+			if (getPreferenceStore().getBoolean(PREDICTED_INTEREST_ERRORS)) {
+				problemListener.enable();
+			}
+			getPreferenceStore().addPropertyChangeListener(problemListener);
+
+			final IWorkbench workbench = PlatformUI.getWorkbench();
+			workbench.getDisplay().asyncExec(new Runnable() {
+				public void run() {
+					if (ApplyMylarToPackageExplorerAction.getDefault() != null) {
+						ApplyMylarToPackageExplorerAction.getDefault().update();
+						getPreferenceStore().addPropertyChangeListener(ApplyMylarToPackageExplorerAction.getDefault());
+					}
+					if (ApplyMylarToBrowsingPerspectiveAction.getDefault() != null) {
+						ApplyMylarToBrowsingPerspectiveAction.getDefault().update();
+					}
+					if (ApplyMylarToBrowsingPerspectiveAction.getDefault() != null) {
+						ApplyMylarToBrowsingPerspectiveAction.getDefault().update();
+					}
+
+					javaEditingMonitor = new JavaEditingMonitor();
+					MylarPlugin.getDefault().getSelectionMonitors().add(javaEditingMonitor);
+					installEditorTracker(workbench);
+
+					ISelectionService service = Workbench.getInstance().getActiveWorkbenchWindow().getSelectionService();
+					service.addPostSelectionListener(packageExplorerManager);
+					
+					if (!MylarPlugin.getDefault().suppressWizardsOnStartup() && !getPreferenceStore().contains(MylarPreferenceWizard.MYLAR_FIRST_RUN)) {
+						MylarPreferenceWizard wizard = new MylarPreferenceWizard(FIRST_USE);
+						Shell shell = Workbench.getInstance().getActiveWorkbenchWindow().getShell();
+						if (wizard != null && shell != null && !shell.isDisposed()) {
+							WizardDialog dialog = new WizardDialog(shell, wizard);
+							dialog.create();
+							dialog.open();
+							getPreferenceStore().putValue(MylarPreferenceWizard.MYLAR_FIRST_RUN, "false");
+						}
+					}
+				}
+			});
+			
+			JavaCore.addElementChangedListener(javaElementChangeListener);
+			savePluginPreferences();
+		} catch (Exception e) {
+			MylarPlugin.fail(e, "Mylar Java Plug-in Initialization failed", true);
 		}
-		getPreferenceStore().addPropertyChangeListener(problemListener);
-		
-		final IWorkbench workbench = PlatformUI.getWorkbench();
-        workbench.getDisplay().asyncExec(new Runnable() {
-            public void run() { 
-            	if(!MylarPlugin.getDefault().suppressWizardsOnStartup() && !getPreferenceStore().contains(MylarPreferenceWizard.MYLAR_FIRST_RUN)){
-            		MylarPreferenceWizard wizard= new MylarPreferenceWizard(FIRST_USE);
-	    			Shell shell = Workbench.getInstance().getActiveWorkbenchWindow().getShell();
-	        		if (wizard != null && shell != null && !shell.isDisposed()) { 
-	        			WizardDialog dialog = new WizardDialog(shell, wizard);
-	        			dialog.create();
-	        			dialog.open();
-	        			getPreferenceStore().putValue(MylarPreferenceWizard.MYLAR_FIRST_RUN, "false");
-	        		}
-            	}
-        		
-            	if (ApplyMylarToPackageExplorerAction.getDefault() != null) {
-            		ApplyMylarToPackageExplorerAction.getDefault().update();
-            		getPreferenceStore().addPropertyChangeListener(ApplyMylarToPackageExplorerAction.getDefault());
-            	}
-            	if (ApplyMylarToBrowsingPerspectiveAction.getDefault() != null) {
-            		ApplyMylarToBrowsingPerspectiveAction.getDefault().update();
-            	}
-            	if (ApplyMylarToBrowsingPerspectiveAction.getDefault() != null) {
-            		ApplyMylarToBrowsingPerspectiveAction.getDefault().update();
-            	}
-            	
-            	javaEditingMonitor = new JavaEditingMonitor();
-                MylarPlugin.getDefault().getSelectionMonitors().add(javaEditingMonitor);
-        		installEditorTracker(workbench);
-        		
-        		ISelectionService service = Workbench.getInstance().getActiveWorkbenchWindow().getSelectionService();
-        		service.addPostSelectionListener(packageExplorerManager); 
-        		
-//        		 needed because Mylar source viewer configuration does not get initialized properly
-//        		resetActiveEditor();
-            }
-        });
-		savePluginPreferences();
-		JavaCore.addElementChangedListener(javaElementChangeListener);
 	}
 
 	private void setPreferenceDefaults() {
@@ -141,74 +153,62 @@
 		getPreferenceStore().setDefault(PREDICTED_INTEREST_ERRORS, false);
 	}
 
-    @Override
+	@Override
 	public void stop(BundleContext context) throws Exception {
 		super.stop(context);
 		plugin = null;
 		resourceBundle = null;
+
+		MylarPlugin.getContextManager().removeListener(packageExplorerManager);
+		MylarPlugin.getContextManager().removeListener(typeHistoryManager);
+		MylarPlugin.getContextManager().removeListener(landmarkMarkerManager);
+		MylarPlugin.getContextManager().removeListener(changeSetManager);
 		
-        MylarPlugin.getContextManager().removeListener(packageExplorerManager);
-        MylarPlugin.getContextManager().removeListener(typeHistoryManager);
-        MylarPlugin.getContextManager().removeListener(landmarkMarkerManager);
-        MylarPlugin.getDefault().getSelectionMonitors().remove(javaEditingMonitor);
-        
-    	if (ApplyMylarToPackageExplorerAction.getDefault() != null) {
-    		getPreferenceStore().removePropertyChangeListener(ApplyMylarToPackageExplorerAction.getDefault());
-    	}
-    	    	
-    	if (Workbench.getInstance() != null 
-    		&& Workbench.getInstance().getActiveWorkbenchWindow() != null
-    		&& !Workbench.getInstance().isClosing()) {
-    		ISelectionService service = Workbench.getInstance().getActiveWorkbenchWindow().getSelectionService();
-    		service.removePostSelectionListener(packageExplorerManager); 
-    	}
-    	JavaCore.removeElementChangedListener(javaElementChangeListener);
-        // TODO: uninstall editor tracker
+		MylarPlugin.getDefault().getSelectionMonitors().remove(javaEditingMonitor);
+
+		if (ApplyMylarToPackageExplorerAction.getDefault() != null) {
+			getPreferenceStore().removePropertyChangeListener(ApplyMylarToPackageExplorerAction.getDefault());
+		}
+
+		if (Workbench.getInstance() != null && Workbench.getInstance().getActiveWorkbenchWindow() != null && !Workbench.getInstance().isClosing()) {
+			ISelectionService service = Workbench.getInstance().getActiveWorkbenchWindow().getSelectionService();
+			service.removePostSelectionListener(packageExplorerManager);
+		}
+		JavaCore.removeElementChangedListener(javaElementChangeListener);
+//		CVSUIPlugin.getPlugin().getChangeSetManager().remove(changeSetManager);
+
+		// TODO: uninstall editor tracker
 	}
 
-//	private void resetActiveEditor() {
-//		IEditorPart part = Workbench.getInstance().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
-//		if (part instanceof MylarCompilationUnitEditor) {
-//			MylarCompilationUnitEditor editor = (MylarCompilationUnitEditor)part;
-//			IJavaElement inputElement = editor.getInputJavaElement();
-//			editor.close(true);
-//			try {
-//				JavaUI.openInEditor(inputElement);
-//			} catch (Exception e) {
-//				MylarPlugin.fail(e, "Could not reset active editor", false);
-//			}
-//		}
-//	}
-    
 	private void installEditorTracker(IWorkbench workbench) {
 		editorTracker = new JavaEditorTracker();
 		workbench.addWindowListener(editorTracker);
-		IWorkbenchWindow[] windows= workbench.getWorkbenchWindows();
-		for (int i= 0; i < windows.length; i++) {
+		IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
+		for (int i = 0; i < windows.length; i++) {
 			windows[i].addPageListener(editorTracker);
-			IWorkbenchPage[] pages= windows[i].getPages();
-			for (int j= 0; j < pages.length; j++) {
+			IWorkbenchPage[] pages = windows[i].getPages();
+			for (int j = 0; j < pages.length; j++) {
 				pages[j].addPartListener(editorTracker);
 			}
 		}
-		
+
 		// update editors that are already opened
 		if (Workbench.getInstance().getActiveWorkbenchWindow() != null) {
-	        IWorkbenchPage page = Workbench.getInstance().getActiveWorkbenchWindow().getActivePage();
-	        if (page != null) {
-	            IEditorReference[] references = page.getEditorReferences();
-	            for (int i = 0; i < references.length; i++) {
-	                IEditorPart part = references[i].getEditor(false);
-	                if (part != null  && part instanceof JavaEditor) {
-	                	JavaEditor editor = (JavaEditor)part;
-	                	editorTracker.registerEditor(editor);
-	                	ActiveFoldingListener.resetProjection(editor);
-	                }
-	            }
-	        }
+			IWorkbenchPage page = Workbench.getInstance().getActiveWorkbenchWindow().getActivePage();
+			if (page != null) {
+				IEditorReference[] references = page.getEditorReferences();
+				for (int i = 0; i < references.length; i++) {
+					IEditorPart part = references[i].getEditor(false);
+					if (part != null && part instanceof JavaEditor) {
+						JavaEditor editor = (JavaEditor) part;
+						editorTracker.registerEditor(editor);
+						ActiveFoldingListener.resetProjection(editor);
+					}
+				}
+			}
 		}
 	}
-    
+
 	/**
 	 * Returns the shared instance.
 	 */
@@ -253,9 +253,8 @@
 		return AbstractUIPlugin.imageDescriptorFromPlugin("org.eclipse.mylar.java", path);
 	}
 
-    public static boolean isMylarEditorDefault() {
-		IEditorRegistry editorRegistry = WorkbenchPlugin.getDefault()
-				.getEditorRegistry();
+	public static boolean isMylarEditorDefault() {
+		IEditorRegistry editorRegistry = WorkbenchPlugin.getDefault().getEditorRegistry();
 		IEditorDescriptor desc = editorRegistry.getDefaultEditor("*.java");
 		// return "AspectJ/Java Editor".equals(desc.getLabel());
 
@@ -264,16 +263,13 @@
 
 	public static void setDefaultEditorForJavaFiles(boolean mylar) {
 
-		EditorRegistry editorRegistry = (EditorRegistry) WorkbenchPlugin
-				.getDefault().getEditorRegistry(); // HACK: cast to allow save
+		EditorRegistry editorRegistry = (EditorRegistry) WorkbenchPlugin.getDefault().getEditorRegistry(); // HACK: cast to allow save
 		// to be called
-		IFileEditorMapping[] array = WorkbenchPlugin.getDefault()
-				.getEditorRegistry().getFileEditorMappings();
+		IFileEditorMapping[] array = WorkbenchPlugin.getDefault().getEditorRegistry().getFileEditorMappings();
 
 		// HACK: cast to allow set to be called
 		editorRegistry.setFileEditorMappings((FileEditorMapping[]) array);
-		String defaultEditor = editorRegistry.getDefaultEditor("*.java")
-				.getId();
+		String defaultEditor = editorRegistry.getDefaultEditor("*.java").getId();
 
 		if (mylar) {
 
@@ -293,82 +289,107 @@
 		return typeHistoryManager;
 	}
 
-//    /**
-//	 * 
-//	 * CODE FROM
-//	 * 
-//	 * @see org.eclipse.jdt.ui.actions.CustomFiltersActionGroup
-//	 * 
-//	 * Slightly modified. Needed to initialize the structure view to have no
-//	 * filter
-//	 * 
-//	 */
-//    
-//	private static final String TAG_USER_DEFINED_PATTERNS_ENABLED= "userDefinedPatternsEnabled"; //$NON-NLS-1$
-//	private static final String TAG_USER_DEFINED_PATTERNS= "userDefinedPatterns"; //$NON-NLS-1$
-//	private static final String TAG_LRU_FILTERS = "lastRecentlyUsedFilters"; //$NON-NLS-1$
-//
-//	private static final String SEPARATOR= ",";  //$NON-NLS-1$
-//	
-//	private final String fTargetId = "org.eclipse.jdt.internal.ui.text.QuickOutline";
-	
-//    // HACK: used to disable the filter from the quick outline by default
-//    public void initializeWithPluginContributions() {
-//    	IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
-//    	if (store.contains(getPreferenceKey("TAG_DUMMY_TO_TEST_EXISTENCE")))
-//    		return;
-//    	
-//		FilterDescriptor[] filterDescs= getCachedFilterDescriptors();
-//		Map<String, FilterDescriptor> fFilterDescriptorMap= new HashMap<String, FilterDescriptor>(filterDescs.length);
-//		Map<String, Boolean> fEnabledFilterIds= new HashMap<String, Boolean>(filterDescs.length);
-//		for (int i= 0; i < filterDescs.length; i++) {
-//			String id= filterDescs[i].getId();
-//			Boolean isEnabled= new Boolean(filterDescs[i].isEnabled());
-//			if (fEnabledFilterIds.containsKey(id))
-//				JavaPlugin.logErrorMessage("WARNING: Duplicate id for extension-point \"org.eclipse.jdt.ui.javaElementFilters\""); //$NON-NLS-1$
-//			fEnabledFilterIds.put(id, isEnabled);
-//			fFilterDescriptorMap.put(id, filterDescs[i]);
-//		}
-//		storeViewDefaults(fEnabledFilterIds, store);
-//	}
-    
-//    private void storeViewDefaults(Map<String, Boolean> fEnabledFilterIds, IPreferenceStore store) {
-//		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=22533
-//		store.setValue(getPreferenceKey("TAG_DUMMY_TO_TEST_EXISTENCE"), "storedViewPreferences");//$NON-NLS-1$//$NON-NLS-2$
-//		
-//		store.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED), false);
-//		store.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS), CustomFiltersDialog.convertToString(new String[0],SEPARATOR));
-//
-//		Iterator iter= fEnabledFilterIds.entrySet().iterator();
-//		while (iter.hasNext()) {
-//			Map.Entry entry= (Map.Entry)iter.next();
-//			String id= (String)entry.getKey();
-//			boolean isEnabled= ((Boolean)entry.getValue()).booleanValue();
-//			if(id.equals("org.eclipse.mylar.ui.java.InterestFilter")){
-//				store.setValue(id, false);	
-//			} else {
-//				store.setValue(id, isEnabled);
+	public static ImageDescriptor getEDGE_REF_JUNIT() {
+		return EDGE_REF_JUNIT;
+	}
+
+	public static void setEDGE_REF_JUNIT(ImageDescriptor edge_ref_junit) {
+		EDGE_REF_JUNIT = edge_ref_junit;
+	}
+
+	public MylarChangeSetManager getChangeSetManager() {
+		return changeSetManager;
+	}
+
+//	private void resetActiveEditor() {
+//		IEditorPart part = Workbench.getInstance().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
+//		if (part instanceof MylarCompilationUnitEditor) {
+//			MylarCompilationUnitEditor editor = (MylarCompilationUnitEditor)part;
+//			IJavaElement inputElement = editor.getInputJavaElement();
+//			editor.close(true);
+//			try {
+//				JavaUI.openInEditor(inputElement);
+//			} catch (Exception e) {
+//				MylarPlugin.fail(e, "Could not reset active editor", false);
 //			}
 //		}
-//
-//		StringBuffer buf= new StringBuffer("");
-//		store.setValue(TAG_LRU_FILTERS, buf.toString());
 //	}
 	
-//	private String getPreferenceKey(String tag) {
-//		return "CustomFiltersActionGroup." + fTargetId + '.' + tag; //$NON-NLS-1$
-//	}
-//    
-//	private FilterDescriptor[] getCachedFilterDescriptors() {
-//		FilterDescriptor[] fCachedFilterDescriptors= FilterDescriptor.getFilterDescriptors(fTargetId);
-//		return fCachedFilterDescriptors;
-//	}
+	//    /**
+	//	 * 
+	//	 * CODE FROM
+	//	 * 
+	//	 * @see org.eclipse.jdt.ui.actions.CustomFiltersActionGroup
+	//	 * 
+	//	 * Slightly modified. Needed to initialize the structure view to have no
+	//	 * filter
+	//	 * 
+	//	 */
+	//    
+	//	private static final String TAG_USER_DEFINED_PATTERNS_ENABLED= "userDefinedPatternsEnabled"; //$NON-NLS-1$
+	//	private static final String TAG_USER_DEFINED_PATTERNS= "userDefinedPatterns"; //$NON-NLS-1$
+	//	private static final String TAG_LRU_FILTERS = "lastRecentlyUsedFilters"; //$NON-NLS-1$
+	//
+	//	private static final String SEPARATOR= ",";  //$NON-NLS-1$
+	//	
+	//	private final String fTargetId = "org.eclipse.jdt.internal.ui.text.QuickOutline";
 
-	
-//	/**
-//	 * TODO: remove
-//	 */
-//	public static JavaUiUpdateBridge getModelUpdateBridge() {
-//		return modelUpdateBridge;
-//	}
+	//    // HACK: used to disable the filter from the quick outline by default
+	//    public void initializeWithPluginContributions() {
+	//    	IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
+	//    	if (store.contains(getPreferenceKey("TAG_DUMMY_TO_TEST_EXISTENCE")))
+	//    		return;
+	//    	
+	//		FilterDescriptor[] filterDescs= getCachedFilterDescriptors();
+	//		Map<String, FilterDescriptor> fFilterDescriptorMap= new HashMap<String, FilterDescriptor>(filterDescs.length);
+	//		Map<String, Boolean> fEnabledFilterIds= new HashMap<String, Boolean>(filterDescs.length);
+	//		for (int i= 0; i < filterDescs.length; i++) {
+	//			String id= filterDescs[i].getId();
+	//			Boolean isEnabled= new Boolean(filterDescs[i].isEnabled());
+	//			if (fEnabledFilterIds.containsKey(id))
+	//				JavaPlugin.logErrorMessage("WARNING: Duplicate id for extension-point \"org.eclipse.jdt.ui.javaElementFilters\""); //$NON-NLS-1$
+	//			fEnabledFilterIds.put(id, isEnabled);
+	//			fFilterDescriptorMap.put(id, filterDescs[i]);
+	//		}
+	//		storeViewDefaults(fEnabledFilterIds, store);
+	//	}
+
+	//    private void storeViewDefaults(Map<String, Boolean> fEnabledFilterIds, IPreferenceStore store) {
+	//		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=22533
+	//		store.setValue(getPreferenceKey("TAG_DUMMY_TO_TEST_EXISTENCE"), "storedViewPreferences");//$NON-NLS-1$//$NON-NLS-2$
+	//		
+	//		store.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS_ENABLED), false);
+	//		store.setValue(getPreferenceKey(TAG_USER_DEFINED_PATTERNS), CustomFiltersDialog.convertToString(new String[0],SEPARATOR));
+	//
+	//		Iterator iter= fEnabledFilterIds.entrySet().iterator();
+	//		while (iter.hasNext()) {
+	//			Map.Entry entry= (Map.Entry)iter.next();
+	//			String id= (String)entry.getKey();
+	//			boolean isEnabled= ((Boolean)entry.getValue()).booleanValue();
+	//			if(id.equals("org.eclipse.mylar.ui.java.InterestFilter")){
+	//				store.setValue(id, false);	
+	//			} else {
+	//				store.setValue(id, isEnabled);
+	//			}
+	//		}
+	//
+	//		StringBuffer buf= new StringBuffer("");
+	//		store.setValue(TAG_LRU_FILTERS, buf.toString());
+	//	}
+
+	//	private String getPreferenceKey(String tag) {
+	//		return "CustomFiltersActionGroup." + fTargetId + '.' + tag; //$NON-NLS-1$
+	//	}
+	//    
+	//	private FilterDescriptor[] getCachedFilterDescriptors() {
+	//		FilterDescriptor[] fCachedFilterDescriptors= FilterDescriptor.getFilterDescriptors(fTargetId);
+	//		return fCachedFilterDescriptors;
+	//	}
+
+	//	/**
+	//	 * TODO: remove
+	//	 */
+	//	public static JavaUiUpdateBridge getModelUpdateBridge() {
+	//		return modelUpdateBridge;
+	//	}
 }
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitLaunchConfiguration.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitLaunchConfiguration.java
index 77c2df4..4b4ebb1 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitLaunchConfiguration.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitLaunchConfiguration.java
@@ -26,7 +26,7 @@
  */
 public class MylarJUnitLaunchConfiguration extends JUnitLaunchConfiguration  {
 	
-	protected IType[] getTestTypes(ILaunchConfiguration configuration, IProgressMonitor pm) throws CoreException {
+	protected IType[] getTestTypes(ILaunchConfiguration config, IProgressMonitor pm) throws CoreException {
 		Set<IType> contextTestCases = JUnitTestUtil.getTestCasesInContext();
 		if (contextTestCases.isEmpty()) {
 			abort(JUnitMessages.JUnitBaseLaunchConfiguration_error_notests, null, IJavaLaunchConfigurationConstants.ERR_UNSPECIFIED_MAIN_TYPE); 
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitTabGroup.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitTabGroup.java
index 0e4fa47..dfeedec 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitTabGroup.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarJUnitTabGroup.java
@@ -11,6 +11,7 @@
 
 package org.eclipse.mylar.java.internal.junit;
 
+
 import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
 import org.eclipse.debug.ui.AbstractLaunchConfigurationTabGroup;
 import org.eclipse.debug.ui.CommonTab;
@@ -34,7 +35,7 @@
 	 */
 	public void createTabs(ILaunchConfigurationDialog dialog, String mode) {		
 		ILaunchConfigurationTab[] tabs= new ILaunchConfigurationTab[] {
-//			new JUnitMainTab(),
+			new MylarJUnitMainTab(false), 
 			new JavaArgumentsTab(),
 			new JavaClasspathTab(),
 			new JavaJRETab(),
@@ -45,9 +46,6 @@
 		setTabs(tabs);
 	}
 
-	/**
-	 * @see ILaunchConfigurationTabGroup#setDefaults(ILaunchConfigurationWorkingCopy)
-	 */
 	public void setDefaults(ILaunchConfigurationWorkingCopy config) {
 		super.setDefaults(config); 
 	}
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitLaunchConfiguration.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitLaunchConfiguration.java
index f1826a3..5f3a898 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitLaunchConfiguration.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitLaunchConfiguration.java
@@ -13,6 +13,7 @@
 
 import java.util.Set;
 
+import org.eclipse.core.resources.IProjectNature;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
@@ -26,7 +27,6 @@
 import org.eclipse.pde.core.plugin.IPluginModelBase;
 import org.eclipse.pde.internal.core.PDECore;
 import org.eclipse.pde.internal.ui.PDEPlugin;
-import org.eclipse.pde.internal.ui.PDEUIMessages;
 import org.eclipse.pde.internal.ui.launcher.JUnitLaunchConfiguration;
 
 /**
@@ -45,22 +45,24 @@
 	protected String getTestPluginId(ILaunchConfiguration configuration) throws CoreException {
 		Set<IType> contextTestCases = JUnitTestUtil.getTestCasesInContext();
 		IJavaProject javaProject = null;
-		if (!contextTestCases.isEmpty()) {
-			javaProject = contextTestCases.iterator().next().getJavaProject(); // HACK: might want another project
-		} else {
-			abort(JUnitMessages.JUnitBaseLaunchConfiguration_error_notests, null, IJavaLaunchConfigurationConstants.ERR_UNSPECIFIED_MAIN_TYPE); 
-		}
-		
+		for (IType type : contextTestCases) {
+			IProjectNature nature = type.getJavaProject().getProject().getNature("org.eclipse.pde.PluginNature");
+			if (nature != null) {
+				javaProject = type.getJavaProject(); // HACK: might want another project
+			}
+		}  
 //		IJavaProject javaProject = getJavaProject(configuration);
-		IPluginModelBase model =
-			PDECore.getDefault().getModelManager().findModel(javaProject.getProject());
-		if (model == null)
+		IPluginModelBase model = null;
+		if (javaProject != null) {
+			model = PDECore.getDefault().getModelManager().findModel(javaProject.getProject());	
+		}
+		if (javaProject == null || model == null)
 			throw new CoreException(
 				new Status(
 					IStatus.ERROR,
 					PDEPlugin.PLUGIN_ID,
 					IStatus.ERROR,
-					PDEUIMessages.JUnitLaunchConfiguration_error_notaplugin, 
+					"Could not find JUnit Plug-in Test in Task Context", 
 					null));
 		if (model instanceof IFragmentModel)
 			return ((IFragmentModel)model).getFragment().getPluginId();
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitTabGroup.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitTabGroup.java
index 9eb7f16..1b09e81 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitTabGroup.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/internal/junit/MylarPdeJUnitTabGroup.java
@@ -35,6 +35,7 @@
 		if (PDECore.getDefault().getModelManager().isOSGiRuntime()) {
 			tabs = new ILaunchConfigurationTab[]{
 //					new JUnitMainTab(),
+					new MylarJUnitMainTab(true),
 					new JUnitArgumentsTab(), 
 					new AdvancedLauncherTab(false),
 					 new ConfigurationTab(true), new TracingLauncherTab(),
@@ -43,6 +44,7 @@
 		} else {
 			tabs = new ILaunchConfigurationTab[]{
 //					new JUnitMainTab(),
+					new MylarJUnitMainTab(true),
 					new JUnitArgumentsTab(), 
 					new AdvancedLauncherTab(false),
 					new TracingLauncherTab(), new EnvironmentTab(),
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/JavaUiBridge.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/JavaUiBridge.java
index 19d32c3..9f11b6c 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/JavaUiBridge.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/JavaUiBridge.java
@@ -112,32 +112,4 @@
 		return null;
 	}
 
-//    public void refreshOutline(final Object element, final boolean updateLabels, final boolean setSelection) {
-//        Workbench.getInstance().getDisplay().asyncExec(new Runnable() {
-//            public void run() { 
-//                if (PlatformUI.getWorkbench() == null || PlatformUI.getWorkbench().getActiveWorkbenchWindow() == null) return;
-//                IEditorPart editorPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
-//                final TreeViewer treeViewer = getOutlineTreeViewer(editorPart);
-//                if (treeViewer != null) {
-//                    if (element == null) {
-//                    	treeViewer.getControl().setRedraw(false);
-//    	                treeViewer.refresh(true);
-//    	                treeViewer.getControl().setRedraw(true);
-//                    } else if (element instanceof IJavaElement) {
-//                        IJavaElement toRefresh = (IJavaElement)element;
-//                        if (element instanceof IMember) {
-//                            toRefresh = toRefresh.getParent();
-//                        } 
-//                        treeViewer.getControl().setRedraw(false);
-//                        treeViewer.refresh(toRefresh, updateLabels); 
-//    	                treeViewer.getControl().setRedraw(true);
-//                    }
-//                    if (setSelection) {
-//    	                if(((StructuredSelection)treeViewer.getSelection()).getFirstElement() != element)
-//    	                    treeViewer.setSelection(new StructuredSelection(element));
-//                    }
-//                }
-//            }
-//        });  
-//    }
 }
\ No newline at end of file
diff --git a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/editor/AbstractMylarHyperlinkDetector.java b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/editor/AbstractMylarHyperlinkDetector.java
index 238c0b6..b2d4680 100644
--- a/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/editor/AbstractMylarHyperlinkDetector.java
+++ b/org.eclipse.mylyn.java.ui/src/org/eclipse/mylyn/java/ui/editor/AbstractMylarHyperlinkDetector.java
@@ -17,6 +17,9 @@
 import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
 import org.eclipse.ui.texteditor.ITextEditor;
 
+/**
+ * @author Mik Kersten
+ */
 public abstract class AbstractMylarHyperlinkDetector implements IHyperlinkDetector {
 
 	private ITextEditor editor;
diff --git a/org.eclipse.mylyn.resources.ui/META-INF/MANIFEST.MF b/org.eclipse.mylyn.resources.ui/META-INF/MANIFEST.MF
index d70d4f8..b46a540 100644
--- a/org.eclipse.mylyn.resources.ui/META-INF/MANIFEST.MF
+++ b/org.eclipse.mylyn.resources.ui/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: Mylar XML Plugin
 Bundle-SymbolicName: org.eclipse.mylar.xml; singleton:=true
-Bundle-Version: 0.4.1
+Bundle-Version: 0.4.2
 Bundle-Activator: org.eclipse.mylar.xml.MylarXmlPlugin
 Bundle-Localization: plugin
 Require-Bundle: org.eclipse.ui,
