diff --git a/build/org.eclipse.cdt.build.gcc.core/plugin.xml b/build/org.eclipse.cdt.build.gcc.core/plugin.xml index 036b2b8f894..bc185a5f43f 100644 --- a/build/org.eclipse.cdt.build.gcc.core/plugin.xml +++ b/build/org.eclipse.cdt.build.gcc.core/plugin.xml @@ -15,6 +15,14 @@ class="org.eclipse.cdt.build.gcc.core.GCCUserToolChainProvider" id="org.eclipse.cdt.build.gcc.core.provider.user"> + + + + diff --git a/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/ClangToolChain.java b/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/ClangToolChain.java new file mode 100644 index 00000000000..773e75fcc52 --- /dev/null +++ b/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/ClangToolChain.java @@ -0,0 +1,36 @@ +/******************************************************************************* + * Copyright (c) 2015, 2017 QNX Software Systems and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + *******************************************************************************/ +package org.eclipse.cdt.build.gcc.core; + +import java.nio.file.Path; + +import org.eclipse.cdt.core.build.IToolChainProvider; +import org.eclipse.cdt.core.envvar.IEnvironmentVariable; + +/** + * The Clang toolchain. There's little different from the GCC toolchain other + * than the toolchain type and name. + * + * @author dschaefer + * + */ +public class ClangToolChain extends GCCToolChain { + + private static final String TYPE_ID = "org.eclipse.cdt.build.clang"; //$NON-NLS-1$ + + public ClangToolChain(IToolChainProvider provider, Path pathToToolChain, String arch, + IEnvironmentVariable[] envVars) { + super(provider, pathToToolChain, arch, envVars); + } + + @Override + public String getTypeId() { + return TYPE_ID; + } + +} diff --git a/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCToolChain.java b/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCToolChain.java index ea791e734da..bf9d5839cca 100644 --- a/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCToolChain.java +++ b/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCToolChain.java @@ -51,6 +51,8 @@ import org.eclipse.core.runtime.PlatformObject; */ public class GCCToolChain extends PlatformObject implements IToolChain { + public static final String TYPE_ID = "org.eclipse.cdt.build.gcc"; //$NON-NLS-1$ + private final IToolChainProvider provider; private final String id; private final Path path; @@ -144,6 +146,11 @@ public class GCCToolChain extends PlatformObject implements IToolChain { this.envVars = envVars; } + @Override + public String getTypeId() { + return TYPE_ID; + } + public Path getPath() { return path; } @@ -165,21 +172,20 @@ public class GCCToolChain extends PlatformObject implements IToolChain { @Override public String getName() { - StringBuilder name = new StringBuilder("GCC"); //$NON-NLS-1$ + StringBuilder name = new StringBuilder(); // $NON-NLS-1$ String os = getProperty(ATTR_OS); if (os != null) { - name.append(' '); name.append(os); + name.append(' '); } String arch = getProperty(ATTR_ARCH); if (arch != null) { - name.append(' '); name.append(arch); + name.append(' '); } if (path != null) { - name.append(' '); name.append(path.toString()); } diff --git a/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCUserToolChainProvider.java b/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCUserToolChainProvider.java index b7b25e9d993..368757982a9 100644 --- a/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCUserToolChainProvider.java +++ b/build/org.eclipse.cdt.build.gcc.core/src/org/eclipse/cdt/build/gcc/core/GCCUserToolChainProvider.java @@ -15,7 +15,6 @@ import java.io.Writer; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; -import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -201,16 +200,6 @@ public class GCCUserToolChainProvider implements IUserToolChainProvider { manager.removeToolChain(toolChain); } - @Override - public IToolChain getToolChain(String id) throws CoreException { - Collection tcs = manager.getToolChains(PROVIDER_ID, id); - if (tcs.isEmpty()) { - return null; - } else { - return tcs.iterator().next(); - } - } - private void saveJsonFile() throws IOException { try (Writer writer = new FileWriter(getJsonFile())) { writer.write(new Gson().toJson(toolChains)); diff --git a/core/org.eclipse.cdt.core/.settings/.api_filters b/core/org.eclipse.cdt.core/.settings/.api_filters index 3f75336083e..cc9a57dda17 100644 --- a/core/org.eclipse.cdt.core/.settings/.api_filters +++ b/core/org.eclipse.cdt.core/.settings/.api_filters @@ -1,74 +1,77 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/core/org.eclipse.cdt.core/schema/toolChainProvider.exsd b/core/org.eclipse.cdt.core/schema/toolChainProvider.exsd index 44873b6b79a..78c09ea5a12 100644 --- a/core/org.eclipse.cdt.core/schema/toolChainProvider.exsd +++ b/core/org.eclipse.cdt.core/schema/toolChainProvider.exsd @@ -1,109 +1,132 @@ - - - - - - - - - A toolchain provider provides automatically discovered toolchains when requested. Providers have enablement to make sure they aren't called unless there's a good chance they have toolchains to offer. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - [Enter the first release in which this extension point appears.] - - - - - - - - - [Enter extension point usage example here.] - - - - - - - - - [Enter API information here.] - - - - - - - - - [Enter information about supplied implementation of this extension point.] - - - - - + + + + + + + + + A toolchain provider provides automatically discovered toolchains when requested. Providers have enablement to make sure they aren't called unless there's a good chance they have toolchains to offer. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + [Enter the first release in which this extension point appears.] + + + + + + + + + [Enter extension point usage example here.] + + + + + + + + + [Enter API information here.] + + + + + + + + + [Enter information about supplied implementation of this extension point.] + + + + + diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/CBuildConfiguration.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/CBuildConfiguration.java index edd0c89dd84..8eda72d5a19 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/CBuildConfiguration.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/CBuildConfiguration.java @@ -23,7 +23,6 @@ import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; @@ -119,11 +118,8 @@ public abstract class CBuildConfiguration extends PlatformObject if (tc == null) { // check for other versions - Collection tcs = toolChainManager.getToolChains(typeId, id); - if (!tcs.isEmpty()) { - // TODO grab the newest version - tc = tcs.iterator().next(); - } else { + tc = toolChainManager.getToolChain(typeId, id); + if (tc == null) { throw new CoreException(new Status(IStatus.ERROR, CCorePlugin.PLUGIN_ID, CCorePlugin.STATUS_BUILD_CONFIG_NOT_VALID, String.format(Messages.CBuildConfiguration_ToolchainMissing, config.getName()), diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChain.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChain.java index 3d3cb0dda58..3e9bd08818a 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChain.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChain.java @@ -62,8 +62,10 @@ public interface IToolChain extends IAdaptable { /** * The version of the toolchain * + * @deprecated the version doesn't matter. id's for a given type must be unique. * @return toolchain version */ + @Deprecated String getVersion(); /** @@ -73,6 +75,18 @@ public interface IToolChain extends IAdaptable { */ String getName(); + /** + * The type id for the toolchain. The combination of type id and toolchain id + * uniquely identify the toolchain in the system. + * + * @since 6.4 + */ + default String getTypeId() { + // Subclasses really need to override this. There can be multiple providers for + // a given toolchain type. + return getProvider().getId(); + } + /** * Returns an property of the toolchain. Used to determine applicability of * a toolchain for a given situation. diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainManager.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainManager.java index 08d210cf79f..e1e254dd79f 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainManager.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainManager.java @@ -32,10 +32,19 @@ public interface IToolChainManager { */ IToolChainProvider getProvider(String providerId) throws CoreException; + /** + * Return the UI label for the toolchain type. + * + * @param id + * type toolchain type id + * @return name of the type + * @since 6.4 + */ + String getToolChainTypeName(String typeId); + /** * Return the toolchain from the given provider with the given id and version. * - * @deprecated Version is now irrelevant. id's are unique. * @param providerId * id of provider * @param id @@ -44,6 +53,7 @@ public interface IToolChainManager { * version of toolchain * @return the toolchain * @throws CoreException + * @deprecated version is now irrelevant. id's are unique. */ @Deprecated default IToolChain getToolChain(String providerId, String id, String version) throws CoreException { @@ -51,17 +61,17 @@ public interface IToolChainManager { } /** - * Return the toolChain from the given provider with the given id. + * Return the toolChain with the given type and id. * - * @param providerId - * id of provider + * @param typeId + * id of toolchain type * @param id * id of toolchain * @return the toolchain * @throws CoreException * @since 6.4 */ - IToolChain getToolChain(String providerId, String id) throws CoreException; + IToolChain getToolChain(String typeId, String id) throws CoreException; /** * Return the toolchains provided by the given provider @@ -70,8 +80,12 @@ public interface IToolChainManager { * id of provider * @return toolchains the provider provides * @throws CoreException + * @deprecated we no longer organize toolchains by provider id. */ - Collection getToolChains(String providerId) throws CoreException; + @Deprecated + default Collection getToolChains(String providerId) throws CoreException { + return null; + } /** * Return all versions of toolchains with the given id provided by the given @@ -83,8 +97,12 @@ public interface IToolChainManager { * id of toolchains * @return toolchains with the given id provided by the provider * @throws CoreException + * @deprecated toolchains no longer have multiple versions per id */ - Collection getToolChains(String providerId, String id) throws CoreException; + @Deprecated + default Collection getToolChains(String providerId, String id) throws CoreException { + return null; + } /** * Returns the list of toolchains that have the given properties. diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainProvider.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainProvider.java index d1c11e2fbbe..d23350bb83a 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainProvider.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/core/build/IToolChainProvider.java @@ -36,28 +36,16 @@ public interface IToolChainProvider { /** * Called by the manager to dynamically create the toolchain. * - * @deprecated We have dropped the concept of version. All ids must be unique. * @param id * the id of the toolchain * @param version * the version of the toolchain * @return the toolchain initialized with the settings. + * @deprecated providers do not manage toolchains, call + * IToolManager.getToolChain() instead. */ @Deprecated default IToolChain getToolChain(String id, String version) throws CoreException { - return getToolChain(id); - } - - /** - * Called by the manager to dynamically create the toolchain. - * - * @param id - * the id of the toolchain - * @return the toolchain initialized with the settings. - * @since 6.4 - */ - default IToolChain getToolChain(String id) throws CoreException { - // By default, assumes all toolchains were added at init time. return null; } diff --git a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/build/ToolChainManager.java b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/build/ToolChainManager.java index 1ac9b8b7df7..ed36904ad05 100644 --- a/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/build/ToolChainManager.java +++ b/core/org.eclipse.cdt.core/src/org/eclipse/cdt/internal/core/build/ToolChainManager.java @@ -9,6 +9,7 @@ package org.eclipse.cdt.internal.core.build; import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -24,12 +25,16 @@ import org.eclipse.core.runtime.IExtensionRegistry; import org.eclipse.core.runtime.ISafeRunnable; import org.eclipse.core.runtime.Platform; import org.eclipse.core.runtime.SafeRunner; +import org.eclipse.core.runtime.preferences.InstanceScope; +import org.osgi.service.prefs.BackingStoreException; +import org.osgi.service.prefs.Preferences; public class ToolChainManager implements IToolChainManager { private Map providerElements; private Map providers; - private Map, IToolChain> toolChains; + private Map> toolChains; + private Map toolChainTypeNames = new HashMap<>(); private List orderedToolChains; private List listeners = new ArrayList<>(); @@ -49,39 +54,110 @@ public class ToolChainManager implements IToolChainManager { // Load the discovered toolchains toolChains = new HashMap<>(); - orderedToolChains = new ArrayList<>(); for (IConfigurationElement element : providerElements.values()) { - // TODO check for enablement + switch (element.getName()) { + case "provider": //$NON-NLS-1$ + // TODO check for enablement + try { + IToolChainProvider provider = (IToolChainProvider) element + .createExecutableExtension("class"); //$NON-NLS-1$ + providers.put(element.getAttribute("id"), provider); //$NON-NLS-1$ + provider.init(this); + } catch (CoreException e) { + CCorePlugin.log(e); + } + break; + case "type": //$NON-NLS-1$ + toolChainTypeNames.put(element.getAttribute("id"), element.getAttribute("name")); //$NON-NLS-1$ //$NON-NLS-2$ + break; + } + } + + orderedToolChains = new ArrayList<>(); + Preferences prefs = InstanceScope.INSTANCE.getNode(CCorePlugin.PLUGIN_ID) + .node(getClass().getSimpleName()).node("order"); //$NON-NLS-1$ + String nString = prefs.get("n", ""); //$NON-NLS-1$ //$NON-NLS-2$ + if (!nString.isEmpty()) { try { - IToolChainProvider provider = (IToolChainProvider) element - .createExecutableExtension("class"); //$NON-NLS-1$ - providers.put(element.getAttribute("id"), provider); //$NON-NLS-1$ - provider.init(this); - } catch (CoreException e) { + int n = Integer.parseInt(nString); + for (int i = 0; i < n; ++i) { + String typeId = prefs.get(Integer.toString(i) + ".type", ""); //$NON-NLS-1$ //$NON-NLS-2$ + String id = prefs.get(Integer.toString(i) + ".id", ""); //$NON-NLS-1$ //$NON-NLS-2$ + IToolChain toolChain = getToolChain(typeId, id); + if (toolChain != null) { + orderedToolChains.add(toolChain); + } + } + } catch (NumberFormatException e) { CCorePlugin.log(e); + } catch (CoreException e) { + CCorePlugin.log(e.getStatus()); + } + } + + for (Map type : toolChains.values()) { + for (IToolChain toolChain : type.values()) { + if (!orderedToolChains.contains(toolChain)) { + orderedToolChains.add(toolChain); + } } } } } - private List getId(IToolChain toolChain) { - List id = new ArrayList<>(3); - id.add(toolChain.getProvider().getId()); - id.add(toolChain.getId()); - return id; + @Override + public String getToolChainTypeName(String typeId) { + init(); + String name = toolChainTypeNames.get(typeId); + return name != null ? name : typeId; + } + + private void saveToolChainOrder() { + Preferences prefs = InstanceScope.INSTANCE.getNode(CCorePlugin.PLUGIN_ID) + .node(getClass().getSimpleName()).node("order"); //$NON-NLS-1$ + prefs.put("n", Integer.toString(orderedToolChains.size())); //$NON-NLS-1$ + int i = 0; + for (IToolChain toolChain : orderedToolChains) { + prefs.put(Integer.toString(i) + ".type", toolChain.getTypeId()); //$NON-NLS-1$ + prefs.put(Integer.toString(i) + ".id", toolChain.getId()); //$NON-NLS-1$ + i++; + } + try { + prefs.flush(); + } catch (BackingStoreException e) { + CCorePlugin.log(e); + } } @Override public void addToolChain(IToolChain toolChain) { - orderedToolChains.add(toolChain); - toolChains.put(getId(toolChain), toolChain); + Map type = toolChains.get(toolChain.getTypeId()); + if (type == null) { + type = new HashMap<>(); + toolChains.put(toolChain.getTypeId(), type); + } + type.put(toolChain.getId(), toolChain); + + if (orderedToolChains != null) { + // is null at init time where order will be established later + orderedToolChains.add(toolChain); + saveToolChainOrder(); + } + fireChange(); } @Override public void removeToolChain(IToolChain toolChain) { - orderedToolChains.remove(toolChain); - toolChains.remove(getId(toolChain)); + Map type = toolChains.get(toolChain.getTypeId()); + if (type != null) { + type.remove(toolChain.getId()); + } + + if (orderedToolChains.remove(toolChain)) { + saveToolChainOrder(); + } + fireChange(); } @@ -100,95 +176,47 @@ public class ToolChainManager implements IToolChainManager { } @Override - public IToolChain getToolChain(String providerId, String id) throws CoreException { + public IToolChain getToolChain(String typeId, String id) throws CoreException { init(); - List tid = new ArrayList<>(3); - tid.add(providerId); - tid.add(id); - - IToolChain toolChain = toolChains.get(tid); - if (toolChain != null) { - return toolChain; - } - - // Try the provider - IToolChainProvider realProvider = providers.get(providerId); - if (realProvider != null) { - toolChain = realProvider.getToolChain(id); - if (toolChain != null) { - toolChains.put(getId(toolChain), toolChain); - return toolChain; - } - } - - return null; + Map type = toolChains.get(typeId); + return type != null ? type.get(id) : null; } @Override public Collection getToolChainsMatching(Map properties) { init(); List tcs = new ArrayList<>(); - for (IToolChain toolChain : toolChains.values()) { - boolean matches = true; - for (Map.Entry property : properties.entrySet()) { - String tcProperty = toolChain.getProperty(property.getKey()); - if (tcProperty != null) { - if (!property.getValue().equals(tcProperty)) { - matches = false; - break; + for (Map type : toolChains.values()) { + for (IToolChain toolChain : type.values()) { + boolean matches = true; + for (Map.Entry property : properties.entrySet()) { + String tcProperty = toolChain.getProperty(property.getKey()); + if (tcProperty != null) { + if (!property.getValue().equals(tcProperty)) { + matches = false; + break; + } } } + if (matches) { + tcs.add(toolChain); + } } - if (matches) { - tcs.add(toolChain); - } - } - - // Allow 32-bit compilers on 64-bit machines - // TODO is there a cleaner way to do this? - if ("x86_64".equals(properties.get(IToolChain.ATTR_ARCH))) { //$NON-NLS-1$ - Map properties32 = new HashMap<>(properties); - properties32.put(IToolChain.ATTR_ARCH, "x86"); //$NON-NLS-1$ - tcs.addAll(getToolChainsMatching(properties32)); } return tcs; } - @Override - public Collection getToolChains(String providerId) { - init(); - List tcs = new ArrayList<>(); - for (IToolChain toolChain : toolChains.values()) { - if (toolChain.getProvider().getId().equals(providerId)) { - tcs.add(toolChain); - } - } - return tcs; - } - - @Override - public Collection getToolChains(String providerId, String id) throws CoreException { - init(); - List tcs = new ArrayList<>(); - for (IToolChain toolChain : toolChains.values()) { - if (toolChain.getProvider().getId().equals(providerId) && toolChain.getId().equals(id)) { - tcs.add(toolChain); - } - } - return tcs; - } - @Override public Collection getAllToolChains() throws CoreException { init(); - return orderedToolChains; + return Collections.unmodifiableCollection(orderedToolChains); } @Override public void setToolChainOrder(List orderedToolchains) throws CoreException { - // TODO Auto-generated method stub - + this.orderedToolChains = orderedToolchains; + saveToolChainOrder(); } @Override diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.java index 706eec2282f..a33b9789ac7 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.java @@ -79,6 +79,7 @@ public final class CUIMessages extends NLS { public static String ToolChainPreferencePage_Remove1; public static String ToolChainPreferencePage_RemoveToolchain; public static String ToolChainPreferencePage_Toolchains; + public static String ToolChainPreferencePage_Type; public static String ToolChainPreferencePage_Up; public static String ToolChainPreferencePage_UserDefinedToolchains; public static String OptionalMessageDialog_dontShowAgain; diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.properties b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.properties index 523f0e5c221..4f9c0203453 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.properties +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/CUIMessages.properties @@ -79,6 +79,7 @@ ToolChainPreferencePage_Remove=Remove ToolChainPreferencePage_Remove1=Remove ToolChainPreferencePage_RemoveToolchain=Remove Toolchain ToolChainPreferencePage_Toolchains=Toolchains +ToolChainPreferencePage_Type=Type ToolChainPreferencePage_Up=Up ToolChainPreferencePage_UserDefinedToolchains=User Defined Toolchains diff --git a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/build/ToolChainPreferencePage.java b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/build/ToolChainPreferencePage.java index b0ed4f1a1ab..97eee797d5f 100644 --- a/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/build/ToolChainPreferencePage.java +++ b/core/org.eclipse.cdt.ui/src/org/eclipse/cdt/ui/build/ToolChainPreferencePage.java @@ -69,7 +69,9 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc private Button userEdit; private Button userRemove; - private IToolChainManager manager = CUIPlugin.getService(IToolChainManager.class); + private List toolChains; + + private static IToolChainManager manager = CUIPlugin.getService(IToolChainManager.class); private ISafeRunnable tcListener = () -> Display.getDefault().asyncExec(() -> { availTable.refresh(); @@ -90,10 +92,12 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc IToolChain toolChain = (IToolChain) element; switch (columnIndex) { case 0: - return toolChain.getName(); + return manager.getToolChainTypeName(toolChain.getTypeId()); case 1: - return toolChain.getProperty(IToolChain.ATTR_OS); + return toolChain.getName(); case 2: + return toolChain.getProperty(IToolChain.ATTR_OS); + case 3: return toolChain.getProperty(IToolChain.ATTR_ARCH); } return null; @@ -118,25 +122,19 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc availGroup.setLayout(new GridLayout(2, false)); availTable = createToolChainTable(availGroup); + availTable.setLabelProvider(new TableLabelProvider()); + availTable.setContentProvider(new IStructuredContentProvider() { + @Override + public Object[] getElements(Object inputElement) { + return toolChains.toArray(); + } + }); availTable.getTable().addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { updateButtons(); } }); - availTable.setLabelProvider(new TableLabelProvider()); - availTable.setContentProvider(new IStructuredContentProvider() { - @Override - public Object[] getElements(Object inputElement) { - try { - return manager.getAllToolChains().toArray(); - } catch (CoreException e) { - CUIPlugin.log(e.getStatus()); - return new Object[0]; - } - } - }); - Composite availButtonComp = new Composite(availGroup, SWT.NONE); availButtonComp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true)); @@ -145,10 +143,38 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc availUp = new Button(availButtonComp, SWT.PUSH); availUp.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, false, false)); availUp.setText(CUIMessages.ToolChainPreferencePage_Up); + availUp.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(SelectionEvent e) { + int i = availTable.getTable().getSelectionIndex(); + if (i < 1) { + return; + } + + IToolChain tc = toolChains.get(i - 1); + toolChains.set(i - 1, toolChains.get(i)); + toolChains.set(i, tc); + availTable.refresh(); + } + }); availDown = new Button(availButtonComp, SWT.PUSH); availDown.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, false, false)); availDown.setText(CUIMessages.ToolChainPreferencePage_Down); + availDown.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(SelectionEvent e) { + int i = availTable.getTable().getSelectionIndex(); + if (i < 0 || i > toolChains.size() - 2) { + return; + } + + IToolChain tc = toolChains.get(i + 1); + toolChains.set(i + 1, toolChains.get(i)); + toolChains.set(i, tc); + availTable.refresh(); + } + }); Group userGroup = new Group(control, SWT.NONE); userGroup.setText(CUIMessages.ToolChainPreferencePage_UserDefinedToolchains); @@ -156,12 +182,6 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc userGroup.setLayout(new GridLayout(2, false)); userTable = createToolChainTable(userGroup); - userTable.getTable().addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(SelectionEvent e) { - updateButtons(); - } - }); userTable.setLabelProvider(new TableLabelProvider()); userTable.setContentProvider(new IStructuredContentProvider() { @Override @@ -179,6 +199,12 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc return tcs.toArray(); } }); + userTable.getTable().addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(SelectionEvent e) { + updateButtons(); + } + }); Composite userButtonComp = new Composite(userGroup, SWT.NONE); userButtonComp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true)); @@ -256,6 +282,13 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc } }); + toolChains = new ArrayList(); + try { + toolChains.addAll(manager.getAllToolChains()); + } catch (CoreException e) { + CUIPlugin.log(e.getStatus()); + } + availTable.setInput(manager); userTable.setInput(manager); updateButtons(); @@ -269,6 +302,24 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc super.dispose(); } + @Override + public boolean performOk() { + if (!super.performOk()) { + return false; + } + + try { + if (!toolChains.equals(manager.getAllToolChains())) { + manager.setToolChainOrder(toolChains); + } + } catch (CoreException e) { + CUIPlugin.log(e.getStatus()); + return false; + } + + return true; + } + private TableViewer createToolChainTable(Composite parent) { Composite tableComp = new Composite(parent, SWT.NONE); tableComp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true)); @@ -280,9 +331,13 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc TableColumnLayout tableLayout = new TableColumnLayout(); + TableColumn tableTypeColumn = new TableColumn(table, SWT.LEAD); + tableTypeColumn.setText(CUIMessages.ToolChainPreferencePage_Type); + tableLayout.setColumnData(tableTypeColumn, new ColumnWeightData(2)); + TableColumn tableNameColumn = new TableColumn(table, SWT.LEAD); tableNameColumn.setText(CUIMessages.ToolChainPreferencePage_Name); - tableLayout.setColumnData(tableNameColumn, new ColumnWeightData(6)); + tableLayout.setColumnData(tableNameColumn, new ColumnWeightData(10)); TableColumn tableOSColumn = new TableColumn(table, SWT.LEAD); tableOSColumn.setText(CUIMessages.ToolChainPreferencePage_OS); @@ -298,9 +353,9 @@ public class ToolChainPreferencePage extends PreferencePage implements IWorkbenc } private void updateButtons() { - boolean availSelected = availTable.getTable().getSelectionCount() > 0; - availUp.setEnabled(availSelected); - availDown.setEnabled(availSelected); + int i = availTable.getTable().getSelectionIndex(); + availUp.setEnabled(i > 0); + availDown.setEnabled(i >= 0 && i < toolChains.size() - 2); boolean userSelected = userTable.getTable().getSelectionCount() > 0; userEdit.setEnabled(userSelected); diff --git a/windows/org.eclipse.cdt.msw.build/src/org/eclipse/cdt/msw/build/core/MSVCToolChainProvider.java b/windows/org.eclipse.cdt.msw.build/src/org/eclipse/cdt/msw/build/core/MSVCToolChainProvider.java index 15e928a65a8..fa1c8aa84b5 100644 --- a/windows/org.eclipse.cdt.msw.build/src/org/eclipse/cdt/msw/build/core/MSVCToolChainProvider.java +++ b/windows/org.eclipse.cdt.msw.build/src/org/eclipse/cdt/msw/build/core/MSVCToolChainProvider.java @@ -12,7 +12,6 @@ import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import org.eclipse.cdt.core.build.IToolChain; import org.eclipse.cdt.core.build.IToolChainManager; import org.eclipse.cdt.core.build.IToolChainProvider; import org.eclipse.cdt.msw.build.Activator; @@ -72,10 +71,4 @@ public class MSVCToolChainProvider implements IToolChainProvider { } } - @Override - public IToolChain getToolChain(String id, String version) throws CoreException { - // TODO Auto-generated method stub - return IToolChainProvider.super.getToolChain(id, version); - } - }