From 86864c02fedb88cf2d3d34199b03bd7514d21b89 Mon Sep 17 00:00:00 2001 From: Alena Laskavaia Date: Mon, 28 Jul 2014 15:55:37 -0400 Subject: [PATCH] LaunchBar - junits - more tweaks and refactoring Change-Id: Ia786fd63c07b3240c1535036b443675dd4931eca Signed-off-by: Alena Laskavaia Reviewed-on: https://git.eclipse.org/r/30732 Tested-by: Hudson CI --- .../META-INF/MANIFEST.MF | 4 +- .../core/internal/LaunchBarManagerTest.java | 319 ++++++++++++++- .../core/AbstarctLaunchDescriptorType.java | 5 + .../AbstractLaunchConfigurationProvider.java | 2 +- .../core/ILaunchDescriptorConfigBased.java | 6 + ...ojectBasedLaunchConfigurationProvider.java | 43 ++ .../core/ProjectBasedLaunchDescriptor.java | 38 ++ .../ProjectBasedLaunchDescriptorType.java | 63 +++ .../core/internal/LaunchBarManager.java | 374 +++++++++--------- 9 files changed, 648 insertions(+), 206 deletions(-) create mode 100644 launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchConfigurationProvider.java create mode 100644 launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptor.java create mode 100644 launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptorType.java diff --git a/launch/org.eclipse.cdt.launchbar.core.tests/META-INF/MANIFEST.MF b/launch/org.eclipse.cdt.launchbar.core.tests/META-INF/MANIFEST.MF index bfe846fde74..19808625490 100644 --- a/launch/org.eclipse.cdt.launchbar.core.tests/META-INF/MANIFEST.MF +++ b/launch/org.eclipse.cdt.launchbar.core.tests/META-INF/MANIFEST.MF @@ -8,6 +8,8 @@ Require-Bundle: org.eclipse.core.runtime, org.junit;bundle-version="4.11.0", org.mockito, org.eclipse.cdt.launchbar.core;bundle-version="1.0.0", - org.eclipse.debug.core + org.eclipse.debug.core, + org.eclipse.cdt.debug.core, + org.eclipse.core.filesystem Bundle-RequiredExecutionEnvironment: JavaSE-1.7 Bundle-ActivationPolicy: lazy diff --git a/launch/org.eclipse.cdt.launchbar.core.tests/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManagerTest.java b/launch/org.eclipse.cdt.launchbar.core.tests/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManagerTest.java index 327fb6b1967..ccd50a03002 100644 --- a/launch/org.eclipse.cdt.launchbar.core.tests/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManagerTest.java +++ b/launch/org.eclipse.cdt.launchbar.core.tests/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManagerTest.java @@ -14,6 +14,8 @@ *******************************************************************************/ package org.eclipse.cdt.launchbar.core.internal; +import static org.junit.Assert.assertNotEquals; +import static org.mockito.Matchers.*; import static org.mockito.Mockito.*; import java.util.ArrayList; @@ -22,6 +24,7 @@ import java.util.HashSet; import junit.framework.TestCase; +import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants; import org.eclipse.cdt.launchbar.core.AbstractLaunchTarget; import org.eclipse.cdt.launchbar.core.AbstractLaunchTargetType; import org.eclipse.cdt.launchbar.core.ConfigBasedLaunchConfigurationProvider; @@ -33,10 +36,17 @@ import org.eclipse.cdt.launchbar.core.ILaunchDescriptor; import org.eclipse.cdt.launchbar.core.ILaunchDescriptorType; import org.eclipse.cdt.launchbar.core.ILaunchTarget; import org.eclipse.cdt.launchbar.core.ILaunchTargetType; +import org.eclipse.cdt.launchbar.core.ProjectBasedLaunchConfigurationProvider; +import org.eclipse.cdt.launchbar.core.ProjectBasedLaunchDescriptorType; import org.eclipse.core.internal.preferences.EclipsePreferences; +import org.eclipse.core.internal.resources.Project; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IExtension; import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.Path; import org.eclipse.core.runtime.preferences.IEclipsePreferences; import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationType; @@ -52,11 +62,11 @@ public class LaunchBarManagerTest extends TestCase { private LaunchBarManager manager; private ILaunchConfigurationProvider provider; private ILaunchDescriptor desc; - private ILaunchDescriptorType descType; + ILaunchDescriptorType descType; private ILaunchConfigurationType lctype; private ILaunchConfiguration lc; - class TargetType extends AbstractLaunchTargetType { + public class TargetType extends AbstractLaunchTargetType { private String id; ArrayList targets = new ArrayList<>(); @@ -90,6 +100,8 @@ public class LaunchBarManagerTest extends TestCase { } private ILaunchTarget mytarget = new LaunchTarget("target_1", targetType); private ILaunchManager lman; + private IProject aaa; + private ArrayList globalmodes = new ArrayList<>(); @Override protected void setUp() throws Exception { @@ -97,6 +109,8 @@ public class LaunchBarManagerTest extends TestCase { doReturn(new IExtension[] {}).when(point).getExtensions(); lman = mock(ILaunchManager.class); doReturn(new ILaunchConfiguration[] {}).when(lman).getLaunchConfigurations(); + doReturn(globalmodes.toArray(new ILaunchMode[globalmodes.size()])).when(lman).getLaunchModes(); + final IEclipsePreferences store = new EclipsePreferences(); manager = new LaunchBarManager() { @Override @@ -119,7 +133,7 @@ public class LaunchBarManagerTest extends TestCase { lctype = mockLCType("lctype1"); lc = mockLC("bla", lctype); // other init - provider = spy(new ConfigBasedLaunchConfigurationProvider(lctype.getIdentifier())); + provider = new ConfigBasedLaunchConfigurationProvider(lctype.getIdentifier()); descType = new ConfigBasedLaunchDescriptorType("desctype1", lctype.getIdentifier()); desc = new ConfigBasedLaunchDescriptor(descType, lc); } @@ -145,7 +159,7 @@ public class LaunchBarManagerTest extends TestCase { return lctype; } - protected ILaunchMode[] mockLaunchMode(ILaunchConfigurationType type, String... modes) { + protected ILaunchMode[] mockLaunchModes(ILaunchConfigurationType type, String... modes) { ILaunchMode res[] = new ILaunchMode[modes.length]; for (int i = 0; i < modes.length; i++) { String modeId = modes[i]; @@ -154,8 +168,10 @@ public class LaunchBarManagerTest extends TestCase { res[i] = mode; doReturn(modeId).when(mode).getIdentifier(); doReturn(mode).when(lman).getLaunchMode(modeId); + globalmodes.add(mode); } doReturn(new HashSet<>(Arrays.asList(modes))).when(type).getSupportedModes(); + doReturn(globalmodes.toArray(new ILaunchMode[globalmodes.size()])).when(lman).getLaunchModes(); return res; } @@ -172,6 +188,25 @@ public class LaunchBarManagerTest extends TestCase { manager.addConfigProvider(descType.getId(), targetType.getId(), false, provider); } + + @Test + public void testAddConfigProviderBad() throws CoreException { + provider = spy(provider); + doThrow(new NullPointerException()).when(provider).init(manager); + manager.addTargetType(targetType); + manager.addDescriptorType(descType, 5); + manager.addConfigProvider(descType.getId(), targetType.getId(), false, provider); + verify(provider).init(manager); + } + + @Test + public void testAddDescriptorTypeBad() throws CoreException { + descType = spy(descType); + doThrow(new NullPointerException()).when(descType).init(manager); + manager.addDescriptorType(descType, 5); + verify(descType).init(manager); + } + @Test public void testAddConfigProviderNoTarget() { try { @@ -211,12 +246,7 @@ public class LaunchBarManagerTest extends TestCase { public void testAddConfigProviderTwo2() throws CoreException { manager.addTargetType(targetType); manager.addDescriptorType(descType, 5); - ILaunchConfigurationProvider provider2 = new ConfigBasedLaunchConfigurationProvider("type2") { - @Override - public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor) throws CoreException { - return lctype; - } - }; + ILaunchConfigurationProvider provider2 = new ConfigBasedLaunchConfigurationProvider("type2"); manager.addConfigProvider(descType.getId(), targetType.getId(), true, provider2); TargetType targetType2 = new TargetType("t2"); manager.addTargetType(targetType2); @@ -224,18 +254,29 @@ public class LaunchBarManagerTest extends TestCase { ILaunchConfigurationType lctype2 = mockLCType("lctypeid2"); ILaunchConfiguration lc2 = mockLC("bla2", lctype2); ConfigBasedLaunchDescriptor desc2 = new ConfigBasedLaunchDescriptor(descType, lc2); - assertEquals(lctype, manager.getLaunchConfigurationType(desc2, null)); + assertEquals(lctype2, manager.getLaunchConfigurationType(desc2, null)); } @Test public void testGetLaunchTargets() throws CoreException { basicSetup(); + manager.launchObjectAdded(lc); manager.setActiveLaunchDescriptor(desc); ILaunchTarget[] launchTargets = manager.getLaunchTargets(); assertEquals(1, launchTargets.length); assertEquals(mytarget, launchTargets[0]); } + @Test + public void testGetLaunchTargetsNoProvider() throws CoreException { + manager.addTargetType(targetType); + targetType.targets.add(mytarget); + manager.addDescriptorType(descType, 5); + manager.launchObjectAdded(lc); + ILaunchTarget[] launchTargets = manager.getLaunchTargets(); + assertEquals(0, launchTargets.length); + } + @Test public void testGetLaunchDescriptorsNull() { ILaunchDescriptor[] launchDescriptors = manager.getLaunchDescriptors(); @@ -274,7 +315,6 @@ public class LaunchBarManagerTest extends TestCase { assertSame(res[0], launchDescriptors[0]); } - @Test public void testLaunchObjectAdded() throws CoreException { basicSetup(); @@ -294,6 +334,131 @@ public class LaunchBarManagerTest extends TestCase { assertEquals(2, manager.getLaunchDescriptors().length); } + public IProject mockProject(String projectName) { + IProject project = mock(Project.class); + when(project.getAdapter(IResource.class)).thenReturn(project); + when(project.getProject()).thenReturn(project); + when(project.getName()).thenReturn(projectName); + IPath path = new Path(projectName); + when(project.getFullPath()).thenReturn(path); + when(project.getType()).thenReturn(IResource.PROJECT); + return project; + } + + public ILaunchConfiguration mockLCProject(ILaunchConfiguration lc, String projectName) { + mockLCAttribute(lc, ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, projectName); + return lc; + } + + public ILaunchConfiguration mockLCBinary(ILaunchConfiguration lc, String binname) { + mockLCAttribute(lc, ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME, binname); + return lc; + } + + public ILaunchConfiguration mockLCAttribute(ILaunchConfiguration lc, String attr, String value) { + try { + when(lc.getAttribute(eq(attr), anyString())).thenReturn(value); + } catch (CoreException e) { + throw new RuntimeException(e); + } + return lc; + } + + protected String getProjectName(ILaunchConfiguration llc) { + try { + return llc.getAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); + } catch (CoreException e) { + // + } + return ""; + } + + IProject getProjectByName(String p) { + if (p.equals("aaa")) + return aaa; + return mockProject(p); + } + + /** + * This scenario when provider will change mapping element->descriptor, depending on other objects involved + */ + @Test + public void testLaunchObjectAddedRemapping() throws CoreException { + projectMappingSetup(); + // user created a project + manager.launchObjectAdded(aaa); + assertEquals(1, manager.getLaunchDescriptors().length); + assertEquals(aaa.getName(), manager.getLaunchDescriptors()[0].getName()); + // user clicked on descriptor geer to edit lc, new lc is created + manager.launchConfigurationAdded(lc); + assertEquals(1, manager.getLaunchDescriptors().length); + assertEquals(lc.getName(), manager.getLaunchDescriptors()[0].getName()); + // user cloned lc and changed some settings + ILaunchConfiguration lc2 = mockLC("lc2", lctype); + mockLCProject(lc2, aaa.getName()); + manager.launchConfigurationAdded(lc2); + assertEquals(2, manager.getLaunchDescriptors().length); + // user deleted lc + manager.launchConfigurationRemoved(lc2); + assertEquals(1, manager.getLaunchDescriptors().length); + // user deleted last lc, now we back to project default + manager.launchConfigurationRemoved(lc); + assertEquals(1, manager.getLaunchDescriptors().length); + } + + protected void projectMappingSetup() { + descType = new ProjectBasedLaunchDescriptorType("desc2", lctype.getIdentifier()) { + protected IProject getProject(ILaunchConfiguration llc) { + return getProjectByName(getProjectName(llc)); + } + + @Override + protected boolean ownsProject(IProject element) { + return true; + } + }; + provider = new ProjectBasedLaunchConfigurationProvider(lctype.getIdentifier()) { + protected IProject getProject(ILaunchConfiguration llc) { + return getProjectByName(getProjectName(llc)); + } + }; + desc = null; + basicSetup(); + aaa = mockProject("aaa"); + mockLCProject(lc, aaa.getName()); + assertEquals(0, manager.getLaunchDescriptors().length); + } + + public void testLaunchObjectAddedRemapping2() throws CoreException { + projectMappingSetup(); + // test unmapping + manager.launchObjectAdded(aaa); + manager.launchObjectAdded(lc); + assertEquals(2, manager.getLaunchDescriptors().length); + manager.launchObjectAdded(aaa); // that would remove aaa mapping since lc is already there + assertEquals(1, manager.getLaunchDescriptors().length); + assertEquals(lc.getName(), manager.getLaunchDescriptors()[0].getName()); + } + + @Test + public void testLaunchObjectAddedBadDescriptor() throws CoreException { + descType = spy(descType); + basicSetup(); + doThrow(new NullPointerException()).when(descType).ownsLaunchObject(any()); + // check events + manager.launchObjectAdded(lc); + verify(descType).ownsLaunchObject(lc); + } + + @Test + public void testLaunchObjectRemoveBadDescriptor() throws CoreException { + descType = spy(descType); + basicSetup(); + doThrow(new NullPointerException()).when(descType).ownsLaunchObject(any()); + // check events + manager.launchObjectRemoved(lc); + } + @Test public void testLaunchObjectRemoved() throws CoreException { basicSetup(); @@ -305,14 +470,52 @@ public class LaunchBarManagerTest extends TestCase { @Test public void testGetActiveLaunchDescriptor() throws CoreException { + basicSetup(); Listener lis = mock(Listener.class); manager.addListener(lis); - - manager.setActiveLaunchDescriptor(desc); + manager.launchObjectAdded(lc); + // manager.setActiveLaunchDescriptor(desc); assertEquals(desc, manager.getActiveLaunchDescriptor()); verify(lis).activeConfigurationDescriptorChanged(); } + @Test + public void testSetActiveLaunchDescriptorUnkn() throws CoreException { + basicSetup(); + try { + manager.setActiveLaunchDescriptor(desc); + fail(); + } catch (Exception e) { + // pass + } + } + + @Test + public void testSetActiveLaunchDescriptorNullBad() throws CoreException { + basicSetup(); + manager.launchObjectAdded(lc); + manager.setActiveLaunchDescriptor(null); + assertEquals(desc, manager.getActiveLaunchDescriptor()); + } + + @Test + public void testSetActiveLaunchDescriptorLisBad() throws CoreException { + basicSetup(); + Listener lis = mock(Listener.class); + manager.addListener(lis); + doThrow(new NullPointerException()).when(lis).activeConfigurationDescriptorChanged(); + manager.launchConfigurationAdded(lc); + verify(lis).activeConfigurationDescriptorChanged(); + } + + @Test + public void testSetActiveLaunchDescriptorNull() throws CoreException { + basicSetup(); + manager.launchObjectAdded(lc); + manager.launchObjectRemoved(lc); + manager.setActiveLaunchDescriptor(null); + } + @Test public void testGetLaunchModes() throws CoreException { ILaunchMode[] launchModes = manager.getLaunchModes(); @@ -320,7 +523,20 @@ public class LaunchBarManagerTest extends TestCase { } @Test - public void testGetActiveLaunchMode() { + public void testGetLaunchModesFew() throws CoreException { + basicSetup(); + + ILaunchConfigurationType lctype2 = mockLCType("lctype2"); + mockLaunchModes(lctype2, "modex"); + mockLaunchModes(lctype, "run", "debug", "foo"); + manager.launchConfigurationAdded(lc); + ILaunchMode[] launchModes = manager.getLaunchModes(); + assertEquals(3, launchModes.length); + } + + + @Test + public void testSetActiveLaunchMode() { ILaunchMode mode = mock(ILaunchMode.class); doReturn("bla").when(mode).getIdentifier(); doReturn("Bla").when(mode).getLabel(); @@ -328,10 +544,55 @@ public class LaunchBarManagerTest extends TestCase { assertEquals(mode, manager.getActiveLaunchMode()); } + @Test + public void testSetActiveLaunchModeNull() { + manager.setActiveLaunchMode(null); + assertEquals(null, manager.getActiveLaunchMode()); + } + + @Test + public void testSetActiveLaunchModeUnsupported() { + basicSetup(); + ILaunchConfigurationType lctype2 = mockLCType("lctype2"); + ILaunchMode mode = mockLaunchModes(lctype2, "modex")[0]; + mockLaunchModes(lctype, "run", "debug", "foo"); + manager.launchConfigurationAdded(lc); + try { + manager.setActiveLaunchMode(mode); + fail(); + } catch (Exception e) { + // works + assertNotEquals(mode, manager.getActiveLaunchMode()); + } + } + + @Test + public void testSetActiveLaunchModeLis() { + ILaunchMode mode = mock(ILaunchMode.class); + doReturn("bla").when(mode).getIdentifier(); + Listener lis = mock(Listener.class); + manager.addListener(lis); + manager.setActiveLaunchMode(mode); + manager.setActiveLaunchMode(null); + verify(lis, times(2)).activeLaunchModeChanged(); + } + + @Test + public void testSetActiveLaunchModeLisBad() { + ILaunchMode mode = mock(ILaunchMode.class); + doReturn("bla").when(mode).getIdentifier(); + Listener lis = mock(Listener.class); + manager.addListener(lis); + doThrow(new NullPointerException()).when(lis).activeLaunchModeChanged(); + manager.setActiveLaunchMode(mode); + verify(lis).activeLaunchModeChanged(); + } + @Test public void testGetActiveLaunchModeFromDesc() throws CoreException { basicSetup(); - mockLaunchMode(lctype, "run"); + mockLaunchModes(lctype, "run"); + manager.launchObjectAdded(lc); manager.setActiveLaunchDescriptor(desc); ILaunchMode resmode = manager.getActiveLaunchMode(); assertNotNull(resmode); @@ -341,7 +602,8 @@ public class LaunchBarManagerTest extends TestCase { @Test public void testGetActiveLaunchModeFromDescDebug() throws CoreException { basicSetup(); - mockLaunchMode(lctype, "run", "debug"); + mockLaunchModes(lctype, "run", "debug"); + manager.launchObjectAdded(lc); manager.setActiveLaunchDescriptor(desc); ILaunchMode resmode = manager.getActiveLaunchMode(); assertNotNull(resmode); @@ -351,8 +613,9 @@ public class LaunchBarManagerTest extends TestCase { @Test public void testGetActiveLaunchModeFromDescActive() throws CoreException { basicSetup(); - mockLaunchMode(lctype, "run"); - ILaunchMode mode = mockLaunchMode(lctype, "foo")[0]; + mockLaunchModes(lctype, "run"); + ILaunchMode mode = mockLaunchModes(lctype, "foo")[0]; + manager.launchObjectAdded(lc); manager.setActiveLaunchMode(mode); manager.setActiveLaunchDescriptor(desc); ILaunchMode resmode = manager.getActiveLaunchMode(); @@ -368,6 +631,16 @@ public class LaunchBarManagerTest extends TestCase { assertEquals(mytarget, manager.getActiveLaunchTarget()); } + @Test + public void testAddTargetTypeBad() { + targetType = spy(targetType); + doThrow(new NullPointerException()).when(targetType).init(manager); + manager.addTargetType(targetType); + targetType.targets.add(mytarget); + assertEquals(mytarget, manager.getLaunchTarget(mytarget.getId())); + verify(targetType).init(manager); + } + @Test public void testGetLaunchTarget() { manager.addTargetType(targetType); @@ -397,9 +670,11 @@ public class LaunchBarManagerTest extends TestCase { manager.addListener(lis); basicSetup(); // check events + manager.launchObjectAdded(lc); manager.setActiveLaunchDescriptor(desc); verify(lis).activeLaunchTargetChanged(); } + @Test public void testAddListenerBad() throws CoreException { Listener lis = mock(Listener.class); @@ -407,6 +682,7 @@ public class LaunchBarManagerTest extends TestCase { doThrow(new NullPointerException()).when(lis).activeLaunchTargetChanged(); basicSetup(); // check events + manager.launchObjectAdded(lc); manager.setActiveLaunchDescriptor(desc); verify(lis).activeLaunchTargetChanged(); } @@ -422,8 +698,9 @@ public class LaunchBarManagerTest extends TestCase { @Test public void testLaunchConfigurationAdded() throws CoreException { + provider = spy(provider); basicSetup(); - ILaunchMode mode = mockLaunchMode(lctype, "foo")[0]; + ILaunchMode mode = mockLaunchModes(lctype, "foo")[0]; manager.launchConfigurationAdded(lc); verify(provider).launchConfigurationAdded(lc); ILaunchDescriptor[] launchDescriptors = manager.getLaunchDescriptors(); @@ -436,6 +713,7 @@ public class LaunchBarManagerTest extends TestCase { } public void testLaunchConfigurationAddedDefault() throws CoreException { + provider = spy(provider); basicSetup(); // emulate default type (if running not from plugin) LocalTargetType localType = new LocalTargetType(); @@ -458,6 +736,7 @@ public class LaunchBarManagerTest extends TestCase { @Test public void testLaunchConfigurationRemoved() throws CoreException { + provider = spy(provider); basicSetup(); manager.launchConfigurationRemoved(lc); verify(provider).launchConfigurationRemoved(lc); diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstarctLaunchDescriptorType.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstarctLaunchDescriptorType.java index 659992c1058..1c1891f01f0 100644 --- a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstarctLaunchDescriptorType.java +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstarctLaunchDescriptorType.java @@ -49,4 +49,9 @@ public abstract class AbstarctLaunchDescriptorType implements ILaunchDescriptorT return false; return true; } + + @Override + public String toString() { + return getId(); + } } diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstractLaunchConfigurationProvider.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstractLaunchConfigurationProvider.java index da445c108db..facfd366dd3 100644 --- a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstractLaunchConfigurationProvider.java +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/AbstractLaunchConfigurationProvider.java @@ -15,7 +15,7 @@ import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationType; /** - * Abstract provider can work with any ITypeBaseLaunchDescriptor to provide launch configurations + * Abstract provider can work with any ILaunchDescriptorConfigBased to provide launch configurations */ public abstract class AbstractLaunchConfigurationProvider implements ILaunchConfigurationProvider { protected ILaunchBarManager manager; diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ILaunchDescriptorConfigBased.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ILaunchDescriptorConfigBased.java index eefa5f8d4db..eae5ec22e47 100644 --- a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ILaunchDescriptorConfigBased.java +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ILaunchDescriptorConfigBased.java @@ -12,6 +12,12 @@ package org.eclipse.cdt.launchbar.core; import org.eclipse.debug.core.ILaunchConfiguration; +/** + * Interface for descriptors which are based on launch configurations + */ public interface ILaunchDescriptorConfigBased extends ILaunchDescriptor { + /** + * Return launch configuration on which it is based + */ public ILaunchConfiguration getConfig(); } diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchConfigurationProvider.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchConfigurationProvider.java new file mode 100644 index 00000000000..71bb95e3ed5 --- /dev/null +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchConfigurationProvider.java @@ -0,0 +1,43 @@ +/******************************************************************************* + * Copyright (c) 2014 QNX Software Systems. All Rights Reserved. + * + * You must obtain a written license from and pay applicable license fees to QNX + * Software Systems before you may reproduce, modify or distribute this software, + * or any work that includes all or part of this software. Free development + * licenses are available for evaluation and non-commercial purposes. For more + * information visit [http://licensing.qnx.com] or email licensing@qnx.com. + * + * This file may contain contributions from others. Please review this entire + * file for other proprietary rights or license notices, as well as the QNX + * Development Suite License Guide at [http://licensing.qnx.com/license-guide/] + * for other information. + *******************************************************************************/ +package org.eclipse.cdt.launchbar.core; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.debug.core.ILaunchConfiguration; + +public abstract class ProjectBasedLaunchConfigurationProvider extends ConfigBasedLaunchConfigurationProvider { + public ProjectBasedLaunchConfigurationProvider(String launchConfigurationTypeId) { + super(launchConfigurationTypeId); + } + + @Override + public boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException { + boolean res = super.launchConfigurationAdded(configuration); + IProject project = getProject(configuration); + getManager().launchObjectRemoved(project); + return res; + } + + @Override + public boolean launchConfigurationRemoved(ILaunchConfiguration configuration) throws CoreException { + boolean res = super.launchConfigurationRemoved(configuration); + IProject project = getProject(configuration); + getManager().launchObjectAdded(project); + return res; + } + + protected abstract IProject getProject(ILaunchConfiguration llc); +} \ No newline at end of file diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptor.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptor.java new file mode 100644 index 00000000000..2ff30b9d56f --- /dev/null +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptor.java @@ -0,0 +1,38 @@ +/******************************************************************************* + * Copyright (c) 2014 QNX Software Systems. All Rights Reserved. + * + * You must obtain a written license from and pay applicable license fees to QNX + * Software Systems before you may reproduce, modify or distribute this software, + * or any work that includes all or part of this software. Free development + * licenses are available for evaluation and non-commercial purposes. For more + * information visit [http://licensing.qnx.com] or email licensing@qnx.com. + * + * This file may contain contributions from others. Please review this entire + * file for other proprietary rights or license notices, as well as the QNX + * Development Suite License Guide at [http://licensing.qnx.com/license-guide/] + * for other information. + *******************************************************************************/ +package org.eclipse.cdt.launchbar.core; + +import org.eclipse.core.resources.IProject; +import org.eclipse.debug.core.ILaunchConfiguration; + +public class ProjectBasedLaunchDescriptor extends ConfigBasedLaunchDescriptor { + private IProject project; + + public ProjectBasedLaunchDescriptor(ILaunchDescriptorType type, IProject p, ILaunchConfiguration lc) { + super(type, lc); + this.project = p; + } + + public String getName() { + if (getConfig() == null) + return project.getName(); + else + return getConfig().getName(); + } + + public IProject getProject() { + return project; + } +} \ No newline at end of file diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptorType.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptorType.java new file mode 100644 index 00000000000..f46912b2cb5 --- /dev/null +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/ProjectBasedLaunchDescriptorType.java @@ -0,0 +1,63 @@ +/******************************************************************************* + * Copyright (c) 2014 QNX Software Systems. All Rights Reserved. + * + * You must obtain a written license from and pay applicable license fees to QNX + * Software Systems before you may reproduce, modify or distribute this software, + * or any work that includes all or part of this software. Free development + * licenses are available for evaluation and non-commercial purposes. For more + * information visit [http://licensing.qnx.com] or email licensing@qnx.com. + * + * This file may contain contributions from others. Please review this entire + * file for other proprietary rights or license notices, as well as the QNX + * Development Suite License Guide at [http://licensing.qnx.com/license-guide/] + * for other information. + *******************************************************************************/ +package org.eclipse.cdt.launchbar.core; + +import org.eclipse.cdt.launchbar.core.internal.Activator; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.debug.core.ILaunchConfiguration; + +public abstract class ProjectBasedLaunchDescriptorType extends ConfigBasedLaunchDescriptorType { + public ProjectBasedLaunchDescriptorType(String descTypeId, String launchConfigTypeId) { + super(descTypeId, launchConfigTypeId); + } + + @Override + public boolean ownsLaunchObject(Object element) { + if (super.ownsLaunchObject(element)) + return true; + if (element instanceof IProject && ownsProject((IProject) element)) + return true; + return false; + } + + protected abstract boolean ownsProject(IProject element); + + @Override + public ILaunchDescriptor getDescriptor(Object element) { + if (element instanceof ILaunchConfiguration) { + ILaunchConfiguration llc = (ILaunchConfiguration) element; + IProject project = getProject(llc); + return new ProjectBasedLaunchDescriptor(this, project, llc); + } else if (element instanceof IProject) { + try { + ILaunchDescriptor[] lds = getManager().getLaunchDescriptors(); + for (int i = 0; i < lds.length; i++) { + ILaunchDescriptor ld = lds[i]; + if (ld instanceof ProjectBasedLaunchDescriptor + && element.equals(((ProjectBasedLaunchDescriptor) ld).getProject())) { + return null; // somebody else has it + } + } + } catch (CoreException e) { + Activator.log(e); + } + return new ProjectBasedLaunchDescriptor(this, (IProject) element, null); + } + return null; + } + + protected abstract IProject getProject(ILaunchConfiguration llc); +} \ No newline at end of file diff --git a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManager.java b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManager.java index 1d05a680497..27f01214580 100644 --- a/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManager.java +++ b/launch/org.eclipse.cdt.launchbar.core/src/org/eclipse/cdt/launchbar/core/internal/LaunchBarManager.java @@ -19,7 +19,6 @@ import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; -import java.util.Set; import org.eclipse.cdt.launchbar.core.ConfigBasedLaunchConfigurationProvider; import org.eclipse.cdt.launchbar.core.ConfigBasedLaunchDescriptorType; @@ -49,30 +48,28 @@ import org.osgi.service.prefs.BackingStoreException; import org.osgi.service.prefs.Preferences; public class LaunchBarManager extends PlatformObject implements ILaunchBarManager, ILaunchConfigurationListener { - private List listeners = new LinkedList<>(); private Map targetTypes = new HashMap<>(); private LinkedHashMap descriptorTypes = new LinkedHashMap<>(); - private Map descriptors = new HashMap<>(); + private final Map descriptors = new LinkedHashMap<>(); private List objectProviders = new ArrayList<>(); // Map descriptor type to target type to provider private Map> configProviders = new HashMap<>(); // Map descriptor type to target type private Map defaultTargetTypes = new HashMap<>(); private Map objectDescriptorMap = new HashMap<>(); - private ILaunchDescriptor activeLaunchDesc; private ILaunchMode activeLaunchMode; private ILaunchTarget activeLaunchTarget; - private ILaunchDescriptor lastLaunchDesc; - private static final String PREF_ACTIVE_CONFIG_DESC = "activeConfigDesc"; private static final String PREF_ACTIVE_LAUNCH_MODE = "activeLaunchMode"; private static final String PREF_ACTIVE_LAUNCH_TARGET = "activeLaunchTarget"; - public LaunchBarManager() throws CoreException { + // Load up the active from the preferences before loading the descriptors + IEclipsePreferences store = getPreferenceStore(); + String activeConfigDescId = store.get(PREF_ACTIVE_CONFIG_DESC, null); IExtensionPoint point = getExtensionPoint(); IExtension[] extensions = point.getExtensions(); // first pass - target, descriptors and object providers @@ -85,7 +82,6 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage String priorityStr = element.getAttribute("priority"); ILaunchDescriptorType type = (ILaunchDescriptorType) element.createExecutableExtension("class"); assert id.equals(type.getId()); - int priority = 1; if (priorityStr != null) { try { @@ -140,40 +136,21 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } - // Load up the active from the preferences before loading the descriptors - IEclipsePreferences store = getPreferenceStore(); - String activeConfigDescId = store.get(PREF_ACTIVE_CONFIG_DESC, null); - - for (ILaunchDescriptorType descriptorType : descriptorTypes.keySet()) { - descriptorType.init(this); - } - - for (ILaunchTargetType targetType : targetTypes.values()) { - targetType.init(this); - } - for (ILaunchObjectProvider objectProvider : objectProviders) { objectProvider.init(this); } - // Hook up the existing launch configurations and listen ILaunchManager launchManager = getLaunchManager(); for (ILaunchConfiguration configuration : launchManager.getLaunchConfigurations()) { launchConfigurationAdded(configuration); } launchManager.addLaunchConfigurationListener(this); - // Now that all the descriptors are loaded, set the one - if (activeConfigDescId == null && !descriptors.isEmpty()) { - activeConfigDescId = getId(descriptors.values().iterator().next()); - } - - if (activeConfigDescId != null) { - ILaunchDescriptor configDesc = descriptors.get(activeConfigDescId); - if (configDesc != null) { - setActiveLaunchDescriptor(configDesc); - } + ILaunchDescriptor configDesc = descriptors.get(activeConfigDescId); + if (configDesc == null) { + configDesc = getLastUsedDescriptor(); } + setActiveLaunchDescriptor(configDesc); } protected static void sortMapByValue(LinkedHashMap map) { @@ -193,24 +170,34 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } public void addDescriptorType(ILaunchDescriptorType type, int priority) { - descriptorTypes.put(type, priority); + descriptorTypes.put(type, priority); sortMapByValue(descriptorTypes); - } + try { + type.init(this); + } catch (Exception e) { + Activator.log(e); + } + } /** * Programmatically add target type */ public void addTargetType(ILaunchTargetType targetType) { targetTypes.put(targetType.getId(), targetType); + try { + targetType.init(this); + } catch (Exception e) { + Activator.log(e); + } } protected ILaunchManager getLaunchManager() { - return DebugPlugin.getDefault().getLaunchManager(); - } + return DebugPlugin.getDefault().getLaunchManager(); + } protected IExtensionPoint getExtensionPoint() { - return Platform.getExtensionRegistry().getExtensionPoint(Activator.PLUGIN_ID, "launchBarContributions"); - } + return Platform.getExtensionRegistry().getExtensionPoint(Activator.PLUGIN_ID, "launchBarContributions"); + } /** * Programmatically add launch configuration provider @@ -232,7 +219,7 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } try { configProvider.init(this); - } catch (CoreException e) { + } catch (Exception e) { Activator.log(e); } } @@ -247,33 +234,31 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage @Override public ILaunchDescriptor launchObjectAdded(Object element) { - ILaunchDescriptor desc = objectDescriptorMap.get(element); - if (desc != null) - return desc; - + ILaunchDescriptor desc = null; + // don't use objectDescriptorMap as cache - provider may decide to remap objects for (ILaunchDescriptorType descriptorType : descriptorTypes.keySet()) { try { if (descriptorType.ownsLaunchObject(element)) { desc = descriptorType.getDescriptor(element); - if (desc != null) { // own the object but do not create descriptor to ignore it - String id = getId(desc); - ILaunchDescriptor old = descriptors.get(id); - if (old != null && !desc.equals(old)) - Activator.log(new IllegalStateException( - "Id of descriptor must be unique within same type " - + "(or descriptors with same id must be equal)")); - descriptors.put(id, desc); + ILaunchDescriptor old = objectDescriptorMap.get(element); + if (old != null) { // old mapping is removed + objectDescriptorMap.remove(element); + descriptors.remove(getId(old)); + } + if (desc != null) { // null if we own the object but do not create descriptor to ignore it + descriptors.put(getId(desc), desc); objectDescriptorMap.put(element, desc); - setActiveLaunchDescriptor(desc); - return desc; + break; } break; } - } catch (CoreException e) { - Activator.log(e.getStatus()); + } catch (Exception e) { + Activator.log(e); } } - return null; + if (desc != null) + setActiveLaunchDescriptor(desc); + return desc; } private String getId(ILaunchDescriptor desc) { @@ -283,20 +268,26 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } @Override - public void launchObjectRemoved(Object element) throws CoreException { + public void launchObjectRemoved(Object element) { ILaunchDescriptor desc = objectDescriptorMap.get(element); if (desc != null) { - descriptors.remove(getId(desc)); objectDescriptorMap.remove(element); + descriptors.remove(getId(desc)); // can multiple elements maps to the same descriptor? if (desc.equals(activeLaunchDesc)) { // Roll back to the last one and make sure we don't come back - ILaunchDescriptor nextDesc = lastLaunchDesc; - activeLaunchDesc = null; + ILaunchDescriptor nextDesc = getLastUsedDescriptor(); setActiveLaunchDescriptor(nextDesc); } } } + protected ILaunchDescriptor getLastUsedDescriptor() { + if (descriptors.size() == 0) + return null; + ILaunchDescriptor[] descs = descriptors.values().toArray(new ILaunchDescriptor[descriptors.size()]); + return descs[descs.length - 1]; + } + @Override public ILaunchDescriptor[] getLaunchDescriptors() { ILaunchDescriptor[] descs = descriptors.values().toArray(new ILaunchDescriptor[descriptors.size()]); @@ -315,62 +306,87 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } @Override - public void setActiveLaunchDescriptor(ILaunchDescriptor configDesc) throws CoreException { - if (activeLaunchDesc == configDesc) + public void setActiveLaunchDescriptor(ILaunchDescriptor configDesc) { + if (activeLaunchDesc == configDesc) { + // Sync since targets could be changed since last time (and modes theoretically too) + syncActiveTarget(); + syncActiveMode(); return; - lastLaunchDesc = activeLaunchDesc; + } + if (configDesc != null && !descriptors.containsValue(configDesc)) + throw new IllegalStateException("Active descriptor must be in the map of descriptors"); + if (configDesc == null) + configDesc = getLastUsedDescriptor(); // do not set to null unless no descriptors activeLaunchDesc = configDesc; - IEclipsePreferences store = getPreferenceStore(); - setPreference(store, PREF_ACTIVE_CONFIG_DESC, getId(activeLaunchDesc)); + if (configDesc != null) { // keeps most used descriptor last + descriptors.remove(configDesc.getId()); + descriptors.put(configDesc.getId(), configDesc); + } + // store in persistent storage + setPreference(getPreferenceStore(), PREF_ACTIVE_CONFIG_DESC, getId(activeLaunchDesc)); // Send notifications - for (Listener listener : listeners) { - try { - listener.activeConfigurationDescriptorChanged(); - } catch (Exception e) { - Activator.log(e); - } - } + updateLaunchDescriptor(activeLaunchDesc); + // Set active target + syncActiveTarget(); + // Set active mode + syncActiveMode(); + } + + protected void syncActiveTarget() { if (activeLaunchDesc == null) { - setActiveLaunchMode(null); setActiveLaunchTarget(null); return; } - - // Set active target - String activeTargetId = store.node(activeLaunchDesc.getId()).get(PREF_ACTIVE_LAUNCH_TARGET, null); - String lastTargetId = store.get(PREF_ACTIVE_LAUNCH_TARGET, null); - String targetIds[] = new String[] { activeTargetId, lastTargetId }; + String activeTargetId = getPerDescriptorStore().get(PREF_ACTIVE_LAUNCH_TARGET, null); + ILaunchTarget targets[] = new ILaunchTarget[] { + activeLaunchTarget, // current active + getLaunchTarget(activeTargetId), // last stored target from persistent storage + getDeafultLaunchTarget() // default target for this desc + }; ILaunchTarget target = null; - for (int i = 0; i < targetIds.length; i++) { - String targetId = targetIds[i]; - target = getLaunchTarget(targetId); + for (int i = 0; i < targets.length; i++) { + target = targets[i]; if (target != null && supportsTargetType(activeLaunchDesc, target.getType())) { break; } } - setActiveLaunchTarget(target); // if target is null this will pick default + setActiveLaunchTarget(target); + } - // Set active mode - ILaunchConfigurationType configType = getLaunchConfigurationType(activeLaunchDesc, activeLaunchTarget); - ILaunchMode foundMode = null; - if (configType != null) { - String activeModeName = store.node(activeLaunchDesc.getId()).get(PREF_ACTIVE_LAUNCH_MODE, null); // last desc mode name - String lastModeName = store.get(PREF_ACTIVE_LAUNCH_MODE, null); // last global mode name - Set supportedModes = configType.getSupportedModes(); - if (supportedModes.size() > 0) { // mna, what if no modes are supported? - ILaunchManager launchManager = getLaunchManager(); - String modeNames[] = new String[] { activeModeName, lastModeName, "debug", "run", supportedModes.iterator().next() }; - for (int i = 0; i < modeNames.length && foundMode == null; i++) { - String mode = modeNames[i]; - if (mode != null && supportedModes.contains(mode)) { - foundMode = launchManager.getLaunchMode(mode); - } - } + protected void syncActiveMode() { + if (activeLaunchDesc == null) { + setActiveLaunchMode(null); + return; + } + ILaunchMode foundMode = null; + String storedModeId = getPerDescriptorStore().get(PREF_ACTIVE_LAUNCH_MODE, null); // last desc mode id + String lastActiveModeId = activeLaunchMode == null ? null : activeLaunchMode.getIdentifier(); + ILaunchMode[] supportedModes = getLaunchModes(); // this is based on active desc and target which are already set + if (supportedModes.length > 0) { // mna, what if no modes are supported? + String modeNames[] = new String[] { + storedModeId, lastActiveModeId, + "debug", "run", + supportedModes[0].getIdentifier() + }; + for (int i = 0; i < modeNames.length && foundMode == null; i++) { + foundMode = getLaunchModeByName(modeNames[i], supportedModes); } } setActiveLaunchMode(foundMode); + } + + private ILaunchMode getLaunchModeByName(String mode, ILaunchMode[] supportedModes) { + if (mode == null) + return null; + for (int j = 0; j < supportedModes.length; j++) { + ILaunchMode lm = supportedModes[j]; + if (lm.getIdentifier().equals(mode)) { + return lm; + } + } + return null; } protected void setPreference(Preferences store, String prefId, String value) { @@ -386,6 +402,12 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } } + protected Preferences getPerDescriptorStore() { + if (activeLaunchDesc == null) + return getPreferenceStore(); + return getPreferenceStore().node(activeLaunchDesc.getId()); + } + protected IEclipsePreferences getPreferenceStore() { return InstanceScope.INSTANCE.getNode(Activator.PLUGIN_ID); } @@ -393,16 +415,19 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage @Override public void updateLaunchDescriptor(ILaunchDescriptor configDesc) { for (Listener listener : listeners) { - listener.activeConfigurationDescriptorChanged(); + try { + listener.activeConfigurationDescriptorChanged(); + } catch (Exception e) { + Activator.log(e); + } } } @Override - public ILaunchMode[] getLaunchModes() throws CoreException { + public ILaunchMode[] getLaunchModes() { ILaunchConfigurationType configType = getLaunchConfigurationType(activeLaunchDesc, activeLaunchTarget); if (configType == null) return new ILaunchMode[0]; - List modeList = new ArrayList<>(); ILaunchMode[] modes = getLaunchManager().getLaunchModes(); for (ILaunchMode mode : modes) { @@ -410,7 +435,6 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage modeList.add(mode); } } - return modeList.toArray(new ILaunchMode[modeList.size()]); } @@ -423,17 +447,11 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage public void setActiveLaunchMode(ILaunchMode mode) { if (activeLaunchMode == mode) return; - try { - ILaunchConfigurationType configType = getLaunchConfigurationType(activeLaunchDesc, activeLaunchTarget); - if (!(activeLaunchDesc == null || mode == null || (configType != null && configType.supportsMode(mode.getIdentifier())))) - throw new IllegalStateException("Mode is not supported by descriptor"); - } catch (CoreException e) { - Activator.log(e); - return; - } + ILaunchConfigurationType configType = getLaunchConfigurationType(activeLaunchDesc, activeLaunchTarget); + if (!(activeLaunchDesc == null || mode == null || (configType != null && configType.supportsMode(mode.getIdentifier())))) + throw new IllegalStateException("Mode is not supported by descriptor"); // change mode activeLaunchMode = mode; - // notify listeners for (Listener listener : listeners) { try { @@ -442,12 +460,11 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage Activator.log(e); } } - // store mode - String modeId = mode == null ? null : mode.getIdentifier(); - setPreference(getPreferenceStore(), PREF_ACTIVE_LAUNCH_MODE, modeId); // global store if (activeLaunchDesc == null) return; - setPreference(getPreferenceStore().node(activeLaunchDesc.getId()), PREF_ACTIVE_LAUNCH_MODE, modeId); // per desc store + // store mode + String modeId = mode == null ? null : mode.getIdentifier(); + setPreference(getPerDescriptorStore(), PREF_ACTIVE_LAUNCH_MODE, modeId); // per desc store } @Override @@ -458,7 +475,6 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage public ILaunchTarget[] getLaunchTargets(ILaunchDescriptor desc) { if (desc == null) return new ILaunchTarget[0]; - List targetList = new ArrayList<>(); Map targetMap = configProviders.get(desc.getType().getId()); if (targetMap != null) { @@ -483,12 +499,27 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage @Override public void setActiveLaunchTarget(ILaunchTarget target) { if (target == null) { - // try and select another target + // try and select another target XXX this should not be an API target = getDeafultLaunchTarget(); } if (activeLaunchTarget == target) return; activeLaunchTarget = target; + updateLaunchTarget(activeLaunchTarget); + if (target == null) { + return; // no point storing null, if stored id is invalid it won't be used anyway + } + target.setActive(); + if (activeLaunchDesc == null) + return; + // per desc store + if (supportsTargetType(activeLaunchDesc, target.getType())) + setPreference(getPerDescriptorStore(), + PREF_ACTIVE_LAUNCH_TARGET, target.getId()); + } + + @Override + public void updateLaunchTarget(ILaunchTarget target) { for (Listener listener : listeners) { try { listener.activeLaunchTargetChanged(); @@ -496,34 +527,16 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage Activator.log(e); } } - if (target == null) { - return; // no point storing null, if stored id is invalid it won't be used anyway - } - target.setActive(); - // global store - setPreference(getPreferenceStore(), PREF_ACTIVE_LAUNCH_TARGET, target.getId()); - if (activeLaunchDesc == null) - return; - // per desc store - if (supportsTargetType(activeLaunchDesc, target.getType())) - setPreference(getPreferenceStore().node(activeLaunchDesc.getName()), - PREF_ACTIVE_LAUNCH_TARGET, target.getId()); - } - - @Override - public void updateLaunchTarget(ILaunchTarget target) { - for (Listener listener : listeners) - listener.activeLaunchTargetChanged(); } protected ILaunchTarget getDeafultLaunchTarget() { ILaunchTarget target = null; - ILaunchTarget[] targets = getLaunchTargets(); - if (targets.length > 0) { - target = targets[0]; - } - return target; - } + ILaunchTarget[] targets = getLaunchTargets(); + if (targets.length > 0) { + target = targets[0]; + } + return target; + } @Override public ILaunchTarget getLaunchTarget(String targetId) { @@ -538,23 +551,27 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage } @Override - public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, ILaunchTarget target) throws CoreException { + public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, ILaunchTarget target) { if (descriptor == null) return null; - - String descriptorTypeId = descriptor.getType().getId(); - Map targetMap = configProviders.get(descriptorTypeId); - if (targetMap != null) { - String targetTypeId = target != null ? target.getType().getId() : defaultTargetTypes.get(descriptorTypeId); - if (targetTypeId != null) { - ILaunchConfigurationProvider configProvider = targetMap.get(targetTypeId); - if (configProvider != null) { - return configProvider.getLaunchConfigurationType(descriptor); + try { + if (descriptor instanceof ILaunchDescriptorConfigBased) { + // if descriptor is launch config based we don't need provider to determine the type + return ((ILaunchDescriptorConfigBased) descriptor).getConfig().getType(); + } + String descriptorTypeId = descriptor.getType().getId(); + Map targetMap = configProviders.get(descriptorTypeId); + if (targetMap != null) { + String targetTypeId = target != null ? target.getType().getId() : defaultTargetTypes.get(descriptorTypeId); + if (targetTypeId != null) { + ILaunchConfigurationProvider configProvider = targetMap.get(targetTypeId); + if (configProvider != null) { + return configProvider.getLaunchConfigurationType(descriptor); + } } } - } - if (descriptor instanceof ILaunchDescriptorConfigBased) { - return ((ILaunchDescriptorConfigBased) descriptor).getConfig().getType(); + } catch (Exception e) { + Activator.log(e); // we calling provider code inside try block, better be safe } return null; } @@ -562,25 +579,17 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage public boolean supportsTargetType(ILaunchDescriptor descriptor, ILaunchTargetType targetType) { if (descriptor == null || targetType == null) return false; - - String descriptorTypeId = descriptor.getType().getId(); - Map targetMap = configProviders.get(descriptorTypeId); + Map targetMap = configProviders.get(descriptor.getType().getId()); if (targetMap != null) { - String targetTypeId = targetType.getId(); - ILaunchConfigurationProvider configProvider = targetMap.get(targetTypeId); - if (configProvider != null) { - return true; - } + return targetMap.get(targetType.getId()) != null; } - return false; } @Override public ILaunchConfiguration getLaunchConfiguration(ILaunchDescriptor descriptor, ILaunchTarget target) throws CoreException { - if (activeLaunchDesc == null || target == null) + if (descriptor == null || target == null) return null; - Map targetMap = configProviders.get(descriptor.getType().getId()); if (targetMap != null) { ILaunchConfigurationProvider configProvider = targetMap.get(target.getType().getId()); @@ -603,46 +612,43 @@ public class LaunchBarManager extends PlatformObject implements ILaunchBarManage @Override public void launchConfigurationAdded(ILaunchConfiguration configuration) { - try { - // TODO filter by launch configuration type to avoid loading plug-ins - for (ILaunchDescriptorType descriptorType : descriptorTypes.keySet()) { - Map targetMap = configProviders.get(descriptorType.getId()); - for (ILaunchConfigurationProvider configProvider : targetMap.values()) { + // TODO filter by launch configuration type to avoid loading plug-ins + for (ILaunchDescriptorType descriptorType : descriptorTypes.keySet()) { + Map targetMap = configProviders.get(descriptorType.getId()); + for (ILaunchConfigurationProvider configProvider : targetMap.values()) { + try { if (configProvider.launchConfigurationAdded(configuration)) { return; } + } catch (Exception e) { + Activator.log(e); // don't let one bad provider affect the rest } } - - // No one claimed it, send it through the descriptorTypes - launchObjectAdded(configuration); - } catch (CoreException e) { - Activator.log(e.getStatus()); } + // No one claimed it, send it through the descriptorTypes + launchObjectAdded(configuration); } @Override public void launchConfigurationRemoved(ILaunchConfiguration configuration) { - try { - // TODO filter by launch configuration type - for (ILaunchDescriptorType descriptorType : descriptorTypes.keySet()) { - Map targetMap = configProviders.get(descriptorType.getId()); - for (ILaunchConfigurationProvider configProvider : targetMap.values()) { + // TODO filter by launch configuration type + for (ILaunchDescriptorType descriptorType : descriptorTypes.keySet()) { + Map targetMap = configProviders.get(descriptorType.getId()); + for (ILaunchConfigurationProvider configProvider : targetMap.values()) { + try { if (configProvider.launchConfigurationRemoved(configuration)) { return; } + } catch (Exception e) { + Activator.log(e); // don't let one bad provider affect the rest } } - - launchObjectRemoved(configuration); - } catch (CoreException e) { - Activator.log(e.getStatus()); } + launchObjectRemoved(configuration); } @Override public void launchConfigurationChanged(ILaunchConfiguration configuration) { // Nothing to do on changes } - }