Attachment #188199 for bug #114563

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2005, 2009 IBM Corporation 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

package org.eclipse.ant.internal.ui.launchConfigurations;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.ant.internal.ui.AntUIImages;

    }

    public void performApply(ILaunchConfigurationWorkingCopy configuration) {
        StringBuffer buffer= new StringBuffer();
        if (!fAfterCleanTargetText.getText().equals(NOT_ENABLED)) {
            buffer.append(IExternalToolConstants.BUILD_TYPE_FULL).append(',');
        } 
        if (!fManualBuildTargetText.getText().equals(NOT_ENABLED)){
            buffer.append(IExternalToolConstants.BUILD_TYPE_INCREMENTAL).append(','); 
            kinds.add(IExternalToolConstants.BUILD_TYPE_INCREMENTAL); 
        } 
        if (!fAutoBuildTargetText.getText().equals(NOT_ENABLED)) {
            buffer.append(IExternalToolConstants.BUILD_TYPE_AUTO).append(',');
        }
        if (!fDuringCleanTargetText.getText().equals(NOT_ENABLED)) {
            buffer.append(IExternalToolConstants.BUILD_TYPE_CLEAN);
        }
        StringBuffer buffer= new StringBuffer();
		for(Iterator i = kinds.iterator(); i.hasNext();) {
			buffer.append(i.next());
			if(i.hasNext()) {
				buffer.append(',');
			}
		}
        configuration.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, buffer.toString());
        
        String targets= (String) fAttributeToTargets.get(IAntLaunchConstants.ATTR_ANT_AFTER_CLEAN_TARGETS);

Lines 1-5 Link Here

(-)src/org/eclipse/core/externaltools/internal/model/BuilderCoreUtils.java (-28 / +34 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 39-44 Link Here
39	public class BuilderCoreUtils {	39	public class BuilderCoreUtils {
40		40
41	public static final String LAUNCH_CONFIG_HANDLE = "LaunchConfigHandle"; //$NON-NLS-1$	41	public static final String LAUNCH_CONFIG_HANDLE = "LaunchConfigHandle"; //$NON-NLS-1$
		42	/**
		43	* Constant added to the build command to determine if we are doing an incremental build after a clean
		44	*
		45	* @since 3.7
		46	*/
		47	public static final String INC_CLEAN = "incclean"; //$NON-NLS-1$
42		48
43	/**	49	/**
44	* Constant used to find a builder using the 3.0-interim format	50	* Constant used to find a builder using the 3.0-interim format
Lines 113-153 Link Here
113	return configuration;	119	return configuration;
114	}	120	}
115		121
116	public static void configureTriggers(ILaunchConfiguration config,	122	public static void configureTriggers(ILaunchConfiguration config, ICommand newCommand) throws CoreException {
117	ICommand newCommand) throws CoreException {
118	newCommand.setBuilding(IncrementalProjectBuilder.FULL_BUILD, false);	123	newCommand.setBuilding(IncrementalProjectBuilder.FULL_BUILD, false);
119	newCommand.setBuilding(IncrementalProjectBuilder.INCREMENTAL_BUILD,	124	newCommand.setBuilding(IncrementalProjectBuilder.INCREMENTAL_BUILD, false);
120	false);
121	newCommand.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, false);	125	newCommand.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, false);
122	newCommand.setBuilding(IncrementalProjectBuilder.CLEAN_BUILD, false);	126	newCommand.setBuilding(IncrementalProjectBuilder.CLEAN_BUILD, false);
123	String buildKinds = config.getAttribute(	127	Map args = newCommand.getArguments();
124	IExternalToolConstants.ATTR_RUN_BUILD_KINDS, (String) null);	128	String buildKinds = config.getAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, (String) null);
125	int[] triggers = BuilderCoreUtils.buildTypesToArray(buildKinds);	129	int[] triggers = buildTypesToArray(buildKinds);
		130	boolean isfull = false, isinc = false;
126	for (int i = 0; i < triggers.length; i++) {	131	for (int i = 0; i < triggers.length; i++) {
127	switch (triggers[i]) {	132	switch (triggers[i]) {
128	case IncrementalProjectBuilder.FULL_BUILD:	133	case IncrementalProjectBuilder.FULL_BUILD:
129	newCommand.setBuilding(IncrementalProjectBuilder.FULL_BUILD,	134	newCommand.setBuilding(IncrementalProjectBuilder.FULL_BUILD, true);
130	true);	135	isfull = true;
131	break;	136	break;
132	case IncrementalProjectBuilder.INCREMENTAL_BUILD:	137	case IncrementalProjectBuilder.INCREMENTAL_BUILD:
133	newCommand.setBuilding(	138	newCommand.setBuilding(IncrementalProjectBuilder.INCREMENTAL_BUILD, true);
134	IncrementalProjectBuilder.INCREMENTAL_BUILD, true);	139	isinc = true;
135	break;	140	break;
136	case IncrementalProjectBuilder.AUTO_BUILD:	141	case IncrementalProjectBuilder.AUTO_BUILD:
137	newCommand.setBuilding(IncrementalProjectBuilder.AUTO_BUILD,	142	newCommand.setBuilding(IncrementalProjectBuilder.AUTO_BUILD, true);
138	true);	143	break;
139	break;	144	case IncrementalProjectBuilder.CLEAN_BUILD:
140	case IncrementalProjectBuilder.CLEAN_BUILD:	145	newCommand.setBuilding(IncrementalProjectBuilder.CLEAN_BUILD, true);
141	newCommand.setBuilding(IncrementalProjectBuilder.CLEAN_BUILD,	146	break;
142	true);
143	break;
144	}	147	}
145	}	148	}
146	if (!config.getAttribute(	149	if(!isfull && isinc) {
147	IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED, false)) {	150	newCommand.setBuilding(IncrementalProjectBuilder.FULL_BUILD, true);
		151	args.put(INC_CLEAN, Boolean.TRUE.toString());
		152	newCommand.setArguments(args);
		153	}
		154	if (!config.getAttribute(IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED, false)) {
148	ILaunchConfigurationWorkingCopy copy = config.getWorkingCopy();	155	ILaunchConfigurationWorkingCopy copy = config.getWorkingCopy();
149	copy.setAttribute(IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED,	156	copy.setAttribute(IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED, true);
150	true);
151	copy.doSave();	157	copy.doSave();
152	}	158	}
153	}	159	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 IBM Corporation 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Matthew Conway  - Bug 175186
 *******************************************************************************/
package org.eclipse.core.externaltools.internal.model;


import java.util.Map;

import org.eclipse.core.externaltools.internal.ExternalToolsCore;
import org.eclipse.core.externaltools.internal.IExternalToolConstants;
import org.eclipse.core.externaltools.internal.launchConfigurations.ExternalToolsCoreUtil;
import org.eclipse.core.externaltools.internal.registry.ExternalToolMigration;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.Bundle;

/**
 * This project builder implementation will run an external tool during the
 * build process. 
 */
public final class ExternalToolBuilder extends IncrementalProjectBuilder {
	private final class IgnoreTeamPrivateChanges implements IResourceDeltaVisitor {
		private boolean[] fTrueChange;
		private IgnoreTeamPrivateChanges(boolean[] trueChange) {
			super();
			fTrueChange= trueChange;
		}
		public boolean visit(IResourceDelta visitDelta) throws CoreException {
			IResource resource= visitDelta.getResource();
			if (resource instanceof IFile) {
				fTrueChange[0]= true;
				return false;
			}
			return true;
		}
	}

	public static final String ID = "org.eclipse.ui.externaltools.ExternalToolBuilder"; //$NON-NLS-1$;

	private static String buildType = IExternalToolConstants.BUILD_TYPE_NONE;
	
	private static IProject buildProject= null;
    private static IResourceDelta buildDelta= null;
	
	/* (non-Javadoc)
	 * @see org.eclipse.core.internal.events.InternalBuilder#build(int, java.util.Map, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException {		
		if (ExternalToolsCore.getDefault().getBundle().getState() != Bundle.ACTIVE) {
			return null;
		}
		
		ILaunchConfiguration config= BuilderCoreUtils.configFromBuildCommandArgs(getProject(), args, new String[1]);
        if (config == null) {
            throw ExternalToolsCore.newError(ExternalToolsModelMessages.ExternalToolBuilder_0, null);
        }
		IProject[] projectsWithinScope= null;
		IResource[] resources = ExternalToolsCoreUtil.getResourcesForBuildScope(config);
		if (resources != null) {
			projectsWithinScope= new IProject[resources.length];
			for (int i = 0; i < resources.length; i++) {
				projectsWithinScope[i]= resources[i].getProject();
			}
		}
        boolean kindCompatible= commandConfiguredForKind(config, kind);
        if (kindCompatible && configEnabled(config)) {
            doBuildBasedOnScope(resources, kind, config, args, monitor);
        }
        
		return projectsWithinScope;
	}

    private boolean commandConfiguredForKind(ILaunchConfiguration config, int kind) {
        try {
            if (!(config.getAttribute(IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED, false))) {
                ICommand command= getCommand();
                //adapt the builder command to make use of the 3.1 support for setting command build kinds
                //this will only happen once for builder/command defined before the support existed
                BuilderCoreUtils.configureTriggers(config, command);
                IProjectDescription desc= getProject().getDescription();
                ICommand[] commands= desc.getBuildSpec();
                int index= getBuilderCommandIndex(commands, command);
                if (index != -1) {
                    commands[index]= command;
                    desc.setBuildSpec(commands);
                    getProject().setDescription(desc, null);
                    ILaunchConfigurationWorkingCopy copy= config.getWorkingCopy();
                    copy.setAttribute(IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED, true);
                    copy.doSave();
                }
                return command.isBuilding(kind);
            }
        } catch (CoreException e) {
           ExternalToolsCore.log(e);
           return true;
        }
        return true;
    }
    
    private int getBuilderCommandIndex(ICommand[] buildSpec, ICommand command) {
        Map commandArgs= command.getArguments();
        if (commandArgs == null) {
            return -1;
        }
        String handle= (String) commandArgs.get(BuilderCoreUtils.LAUNCH_CONFIG_HANDLE);
        if (handle == null) {
            return -1;
        }
        for (int i = 0; i < buildSpec.length; ++i) {
            ICommand buildSpecCommand= buildSpec[i];
            if (ID.equals(buildSpecCommand.getBuilderName())) {
                Map buildSpecArgs= buildSpecCommand.getArguments();
                if (buildSpecArgs != null) {
                    String buildSpecHandle= (String) buildSpecArgs.get(BuilderCoreUtils.LAUNCH_CONFIG_HANDLE);
                    if (handle.equals(buildSpecHandle)) {
                        return i;
                    }
                }
            }
        }
        return -1;
    }

	/**
	 * Returns whether the given builder config is enabled or not.
	 * 
	 * @param config the config to examine
	 * @return whether the config is enabled
	 */
	private boolean configEnabled(ILaunchConfiguration config) {
		try {
			return ExternalToolsCoreUtil.isBuilderEnabled(config);
		} catch (CoreException e) {
			ExternalToolsCore.log(e);
		}
		return true;
	}

	private void doBuildBasedOnScope(IResource[] resources, int kind, ILaunchConfiguration config, Map args, IProgressMonitor monitor) throws CoreException {
		boolean buildForChange = true;
		if (kind != FULL_BUILD) { //scope not applied for full builds
			if (resources != null && resources.length > 0) {
				buildForChange = buildScopeIndicatesBuild(resources);
			}
		}

		if (buildForChange) {
			launchBuild(kind, config, args, monitor);
		}
	}
	
	private void launchBuild(int kind, ILaunchConfiguration config, Map args, IProgressMonitor monitor) throws CoreException {
		monitor.subTask(NLS.bind(ExternalToolsModelMessages.ExternalToolBuilder_Running__0_____1, new String[] { config.getName()}));
		buildStarted(kind, args);
		// The default value for "launch in background" is true in debug core. If
		// the user doesn't go through the UI, the new attribute won't be set. This means
		// that existing Ant builders will try to run in the background (and likely conflict with
		// each other) without migration.
		ILaunchConfiguration newconfig= ExternalToolMigration.migrateRunInBackground(config);
		newconfig.launch(ILaunchManager.RUN_MODE, monitor);
		buildEnded();
	}

	/**
	 * Returns the build type being performed if the
	 * external tool is being run as a project builder.
	 * 
	 * @return one of the <code>IExternalToolConstants.BUILD_TYPE_*</code> constants.
	 */
	public static String getBuildType() {
		return buildType;
	}
	
	/**
	 * Returns the project that is being built and has triggered the current external
	 * tool builder. <code>null</code> is returned if no build is currently occurring.
	 * 
	 * @return project being built or <code>null</code>.
	 */
	public static IProject getBuildProject() {
		return buildProject;
	}

    /**
     * Returns the <code>IResourceDelta</code> that is being built and has triggered the current external
     * tool builder. <code>null</code> is returned if no build is currently occurring.
     * 
     * @return resource delta for the build or <code>null</code>
     */
    public static IResourceDelta getBuildDelta() {
        return buildDelta;
    }
    
	/**
	 * Stores the currently active build kind and build project when a build begins
	 * @param buildKind
	 * @param args the arguments passed into the builder
	 */
	private void buildStarted(int buildKind, Map args) {
		switch (buildKind) {
			case IncrementalProjectBuilder.INCREMENTAL_BUILD :
				buildType = IExternalToolConstants.BUILD_TYPE_INCREMENTAL;
				buildDelta = getDelta(getProject());
				break;
			case IncrementalProjectBuilder.FULL_BUILD :
				if(args != null && args.containsKey(BuilderCoreUtils.INC_CLEAN)) {
					buildType = IExternalToolConstants.BUILD_TYPE_INCREMENTAL;
					buildDelta = getDelta(getProject());
				}
				else {
					buildType = IExternalToolConstants.BUILD_TYPE_FULL;
				}
				break;
			case IncrementalProjectBuilder.AUTO_BUILD :
				buildType = IExternalToolConstants.BUILD_TYPE_AUTO;
				buildDelta = getDelta(getProject());
				break;
            case IncrementalProjectBuilder.CLEAN_BUILD :
                buildType = IExternalToolConstants.BUILD_TYPE_CLEAN;
                break;
			default :
				buildType = IExternalToolConstants.BUILD_TYPE_NONE;
				break;
		}
		buildProject= getProject();
	}
	
	/**
	 * Clears the current build kind, build project and build delta when a build finishes.
	 */
	private void buildEnded() {
		buildType= IExternalToolConstants.BUILD_TYPE_NONE;
		buildProject= null;
        buildDelta= null;
	}
	
	private boolean buildScopeIndicatesBuild(IResource[] resources) {
		for (int i = 0; i < resources.length; i++) {
			IResourceDelta delta = getDelta(resources[i].getProject());
			if (delta == null) {
				//project just added to the workspace..no previous build tree
				return true;
			} 
			IPath path= resources[i].getProjectRelativePath();
			IResourceDelta change= delta.findMember(path);
			if (change != null) {
				final boolean[] trueChange= new boolean[1];
				trueChange[0]= false;
				try {
					change.accept(new IgnoreTeamPrivateChanges(trueChange));
				} catch (CoreException e) {
					ExternalToolsCore.log("Internal error resolving changed resources during build", e); //$NON-NLS-1$
				}
				
				return trueChange[0]; //filtered out team private changes
			}
		}
		return false;
	}
    
    protected void clean(IProgressMonitor monitor) throws CoreException {
	    ICommand command= getCommand();
        ILaunchConfiguration config= BuilderCoreUtils.configFromBuildCommandArgs(getProject(), command.getArguments(), new String[1]);
    	if (!configEnabled(config)) {
	    	return;
	    }
        
        if ((!config.getAttribute(IExternalToolConstants.ATTR_TRIGGERS_CONFIGURED, false))) {
            //old behavior
            super.clean(monitor);
            return;
        }
	
		launchBuild(IncrementalProjectBuilder.CLEAN_BUILD, config, null, monitor);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation 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

package org.eclipse.ui.externaltools.internal.launchConfigurations;


import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.core.externaltools.internal.IExternalToolConstants;
import org.eclipse.core.externaltools.internal.launchConfigurations.ExternalToolsCoreUtil;
import org.eclipse.core.resources.IResource;

        fVariables.setEnabled(haveOutputFile);
        fAppend.setEnabled(haveOutputFile);
    }

	/* (non-Javadoc)
	 * @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
	 */
	public void performApply(ILaunchConfigurationWorkingCopy configuration) {
        if (fCreateBuildScheduleComponent) {
        	StringBuffer buffer= new StringBuffer();
    		if (afterClean.getSelection()) {
    			buffer.append(IExternalToolConstants.BUILD_TYPE_FULL).append(',');
    		} 
    		if (manualBuild.getSelection()){
    			buffer.append(IExternalToolConstants.BUILD_TYPE_INCREMENTAL).append(','); 
    			kinds.add(IExternalToolConstants.BUILD_TYPE_INCREMENTAL); 
    		} 
    		if (autoBuildButton.getSelection()) {
    			buffer.append(IExternalToolConstants.BUILD_TYPE_AUTO).append(',');
    		}
    		
    		if (fDuringClean.getSelection()) {
    			buffer.append(IExternalToolConstants.BUILD_TYPE_CLEAN);
    		}
    		StringBuffer buffer= new StringBuffer();
    		for(Iterator i = kinds.iterator(); i.hasNext();) {
    			buffer.append(i.next());
    			if(i.hasNext()) {
    				buffer.append(',');
    			}
    		}
    		configuration.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, buffer.toString());
        }

Return to bug 114563

Lines 1-5 Link Here

(-)Ant Tools Support/org/eclipse/ant/internal/ui/launchConfigurations/AntBuilderTargetsTab.java (-16 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2005, 2011 IBM Corporation and others.	2	* Copyright (c) 2005, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-18 Link Here
11	package org.eclipse.ant.internal.ui.launchConfigurations;	11	package org.eclipse.ant.internal.ui.launchConfigurations;
12		12
13	import java.util.HashMap;	13	import java.util.HashMap;
14	import java.util.HashSet;
15	import java.util.Iterator;
16	import java.util.Map;	14	import java.util.Map;
17		15
18	import org.eclipse.ant.internal.ui.AntUIImages;	16	import org.eclipse.ant.internal.ui.AntUIImages;
Lines 296-322 Link Here
296	}	294	}
297		295
298	public void performApply(ILaunchConfigurationWorkingCopy configuration) {	296	public void performApply(ILaunchConfigurationWorkingCopy configuration) {
299	HashSet kinds = new HashSet(4);	297	StringBuffer buffer= new StringBuffer();
300	if (!fAfterCleanTargetText.getText().equals(NOT_ENABLED)) {	298	if (!fAfterCleanTargetText.getText().equals(NOT_ENABLED)) {
301	kinds.add(IExternalToolConstants.BUILD_TYPE_FULL);	299	buffer.append(IExternalToolConstants.BUILD_TYPE_FULL).append(',');
302	}	300	}
303	if (!fManualBuildTargetText.getText().equals(NOT_ENABLED)){	301	if (!fManualBuildTargetText.getText().equals(NOT_ENABLED)){
304	kinds.add(IExternalToolConstants.BUILD_TYPE_FULL);	302	buffer.append(IExternalToolConstants.BUILD_TYPE_INCREMENTAL).append(',');
305	kinds.add(IExternalToolConstants.BUILD_TYPE_INCREMENTAL);
306	}	303	}
307	if (!fAutoBuildTargetText.getText().equals(NOT_ENABLED)) {	304	if (!fAutoBuildTargetText.getText().equals(NOT_ENABLED)) {
308	kinds.add(IExternalToolConstants.BUILD_TYPE_AUTO);	305	buffer.append(IExternalToolConstants.BUILD_TYPE_AUTO).append(',');
309	}	306	}
310	if (!fDuringCleanTargetText.getText().equals(NOT_ENABLED)) {	307	if (!fDuringCleanTargetText.getText().equals(NOT_ENABLED)) {
311	kinds.add(IExternalToolConstants.BUILD_TYPE_CLEAN);	308	buffer.append(IExternalToolConstants.BUILD_TYPE_CLEAN);
312	}	309	}
313	StringBuffer buffer= new StringBuffer();
314	for(Iterator i = kinds.iterator(); i.hasNext();) {
315	buffer.append(i.next());
316	if(i.hasNext()) {
317	buffer.append(',');
318	}
319	}
320	configuration.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, buffer.toString());	310	configuration.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, buffer.toString());
321		311
322	String targets= (String) fAttributeToTargets.get(IAntLaunchConstants.ATTR_ANT_AFTER_CLEAN_TARGETS);	312	String targets= (String) fAttributeToTargets.get(IAntLaunchConstants.ATTR_ANT_AFTER_CLEAN_TARGETS);

Lines 1-5 Link Here

(-)External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsBuilderTab.java (-19 / +8 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2011 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 12-20 Link Here
12	package org.eclipse.ui.externaltools.internal.launchConfigurations;	12	package org.eclipse.ui.externaltools.internal.launchConfigurations;
13		13
14		14
15	import java.util.HashSet;
16	import java.util.Iterator;
17
18	import org.eclipse.core.externaltools.internal.IExternalToolConstants;	15	import org.eclipse.core.externaltools.internal.IExternalToolConstants;
19	import org.eclipse.core.externaltools.internal.launchConfigurations.ExternalToolsCoreUtil;	16	import org.eclipse.core.externaltools.internal.launchConfigurations.ExternalToolsCoreUtil;
20	import org.eclipse.core.resources.IResource;	17	import org.eclipse.core.resources.IResource;
Lines 390-422 Link Here
390	fVariables.setEnabled(haveOutputFile);	387	fVariables.setEnabled(haveOutputFile);
391	fAppend.setEnabled(haveOutputFile);	388	fAppend.setEnabled(haveOutputFile);
392	}	389	}
393		390
394	/* (non-Javadoc)	391	/* (non-Javadoc)
395	* @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)	392	* @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy)
396	*/	393	*/
397	public void performApply(ILaunchConfigurationWorkingCopy configuration) {	394	public void performApply(ILaunchConfigurationWorkingCopy configuration) {
398	if (fCreateBuildScheduleComponent) {	395	if (fCreateBuildScheduleComponent) {
399	HashSet kinds = new HashSet(4);	396	StringBuffer buffer= new StringBuffer();
400	if (afterClean.getSelection()) {	397	if (afterClean.getSelection()) {
401	kinds.add(IExternalToolConstants.BUILD_TYPE_FULL);	398	buffer.append(IExternalToolConstants.BUILD_TYPE_FULL).append(',');
402	}	399	}
403	if(manualBuild.getSelection()){	400	if (manualBuild.getSelection()){
404	kinds.add(IExternalToolConstants.BUILD_TYPE_FULL);	401	buffer.append(IExternalToolConstants.BUILD_TYPE_INCREMENTAL).append(',');
405	kinds.add(IExternalToolConstants.BUILD_TYPE_INCREMENTAL);
406	}	402	}
407	if (autoBuildButton.getSelection()) {	403	if (autoBuildButton.getSelection()) {
408	kinds.add(IExternalToolConstants.BUILD_TYPE_AUTO);	404	buffer.append(IExternalToolConstants.BUILD_TYPE_AUTO).append(',');
409	}	405	}
410		406
411	if (fDuringClean.getSelection()) {	407	if (fDuringClean.getSelection()) {
412	kinds.add(IExternalToolConstants.BUILD_TYPE_CLEAN);	408	buffer.append(IExternalToolConstants.BUILD_TYPE_CLEAN);
413	}
414	StringBuffer buffer= new StringBuffer();
415	for(Iterator i = kinds.iterator(); i.hasNext();) {
416	buffer.append(i.next());
417	if(i.hasNext()) {
418	buffer.append(',');
419	}
420	}	409	}
421	configuration.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, buffer.toString());	410	configuration.setAttribute(IExternalToolConstants.ATTR_RUN_BUILD_KINDS, buffer.toString());
422	}	411	}