Java tutorial
/* * Copyright (c) 2012 IkChan Kwon kighie@gmail.com * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package kr.simula.formula.ide.launcher.ui; import java.io.IOException; import java.text.MessageFormat; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import kr.simula.formula.ide.launcher.FormulaLauncherPlugin; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; import org.eclipse.core.variables.VariablesPlugin; import org.eclipse.debug.core.DebugPlugin; import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; import org.eclipse.debug.internal.ui.DebugUIPlugin; import org.eclipse.debug.internal.ui.IDebugHelpContextIds; import org.eclipse.debug.internal.ui.IInternalDebugUIConstants; import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager; import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsMessages; import org.eclipse.debug.internal.ui.launchConfigurations.LaunchGroupExtension; import org.eclipse.debug.internal.ui.launchConfigurations.LaunchHistory; import org.eclipse.debug.ui.AbstractLaunchConfigurationTab; import org.eclipse.debug.ui.DebugUITools; import org.eclipse.debug.ui.IDebugUIConstants; import org.eclipse.debug.ui.ILaunchGroup; import org.eclipse.debug.ui.StringVariableSelectionDialog; import org.eclipse.dltk.core.DLTKCore; import org.eclipse.dltk.core.environment.EnvironmentManager; import org.eclipse.dltk.core.environment.IExecutionEnvironment; import org.eclipse.dltk.core.environment.IFileHandle; import org.eclipse.dltk.internal.ui.util.SWTUtil; import org.eclipse.dltk.launching.ScriptLaunchConfigurationConstants; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.IDialogSettings; import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.jface.viewers.CheckStateChangedEvent; import org.eclipse.jface.viewers.CheckboxTableViewer; import org.eclipse.jface.viewers.ICheckStateListener; import org.eclipse.jface.viewers.ILabelProviderListener; import org.eclipse.jface.viewers.IStructuredContentProvider; import org.eclipse.jface.viewers.ITableLabelProvider; import org.eclipse.jface.viewers.Viewer; import org.eclipse.swt.SWT; import org.eclipse.swt.events.ModifyEvent; import org.eclipse.swt.events.ModifyListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.events.SelectionListener; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Combo; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.FileDialog; import org.eclipse.swt.widgets.Group; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.WorkbenchEncoding; import org.eclipse.ui.dialogs.ContainerSelectionDialog; import org.eclipse.ui.dialogs.ElementTreeSelectionDialog; import org.eclipse.ui.ide.IDEEncoding; import org.eclipse.ui.model.WorkbenchContentProvider; import org.eclipse.ui.model.WorkbenchLabelProvider; import org.eclipse.ui.views.navigator.ResourceSorter; /** * <pre></pre> * @author kighie@gmail.com * @since 1.0 */ public class FormulaCommonTab extends AbstractLaunchConfigurationTab { /** * Provides a persistable dialog for selecting the shared project location */ class SharedLocationSelectionDialog extends ContainerSelectionDialog { private final String SETTINGS_ID = IDebugUIConstants.PLUGIN_ID + ".SHARED_LAUNCH_CONFIGURATON_DIALOG"; //$NON-NLS-1$ public SharedLocationSelectionDialog(Shell parentShell, IContainer initialRoot, boolean allowNewContainerName, String message) { super(parentShell, initialRoot, allowNewContainerName, message); } protected IDialogSettings getDialogBoundsSettings() { IDialogSettings settings = DebugUIPlugin.getDefault().getDialogSettings(); IDialogSettings section = settings.getSection(SETTINGS_ID); if (section == null) { section = settings.addNewSection(SETTINGS_ID); } return section; } } private static final String EMPTY_STRING = ""; //$NON-NLS-1$ // Local/shared UI widgets private Button fLocalRadioButton; private Button fSharedRadioButton; private Text fSharedLocationText; private Button fSharedLocationButton; private Button fLaunchInBackgroundButton; private Button fDefaultEncodingButton; private Button fAltEncodingButton; private Combo fEncodingCombo; private Button fConsoleOutput; private Button fFileOutput; private Button fFileBrowse; private Text fFileText; private Button fVariables; private Button fAppend; private Button fWorkspaceBrowse; private Button fUseDltkRadio; private Button fNotUseDltkRatio; /** * Check box list for specifying favorites */ private CheckboxTableViewer fFavoritesTable; /** * Modify listener that simply updates the owning launch configuration * dialog. */ private ModifyListener fBasicModifyListener = new ModifyListener() { public void modifyText(ModifyEvent evt) { updateLaunchConfigurationDialog(); } }; /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse * .swt.widgets.Composite) */ public void createControl(Composite parent) { Composite comp = new Composite(parent, SWT.NONE); setControl(comp); PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(), IDebugHelpContextIds.LAUNCH_CONFIGURATION_DIALOG_COMMON_TAB); comp.setLayout(new GridLayout(2, true)); comp.setFont(parent.getFont()); createSharedConfigComponent(comp); createFavoritesComponent(comp); createEncodingComponent(comp); createOutputCaptureComponent(comp); createLaunchInBackgroundComponent(comp); } /** * Creates the favorites control * * @param parent * the parent composite to add this one to * */ private void createFavoritesComponent(Composite parent) { Group favComp = SWTUtil.createGroup(parent, LaunchConfigurationsMessages.CommonTab_Display_in_favorites_menu__10, 1, 1, GridData.FILL_BOTH); fFavoritesTable = CheckboxTableViewer.newCheckList(favComp, SWT.CHECK | SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION); Control table = fFavoritesTable.getControl(); GridData gd = new GridData(GridData.FILL_BOTH); table.setLayoutData(gd); table.setFont(parent.getFont()); fFavoritesTable.setContentProvider(new FavoritesContentProvider()); fFavoritesTable.setLabelProvider(new FavoritesLabelProvider()); fFavoritesTable.addCheckStateListener(new ICheckStateListener() { public void checkStateChanged(CheckStateChangedEvent event) { updateLaunchConfigurationDialog(); } }); } /** * Creates the shared config component * * @param parent * the parent composite to add this component to * */ private void createSharedConfigComponent(Composite parent) { Group group = SWTUtil.createGroup(parent, LaunchConfigurationsMessages.CommonTab_0, 3, 2, GridData.FILL_HORIZONTAL); fLocalRadioButton = createRadioButton(group, LaunchConfigurationsMessages.CommonTab_L_ocal_3); GridData gd = new GridData(); gd.horizontalSpan = 3; fLocalRadioButton.setLayoutData(gd); fSharedRadioButton = createRadioButton(group, LaunchConfigurationsMessages.CommonTab_S_hared_4); fSharedRadioButton.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent evt) { handleSharedRadioButtonSelected(); } }); fSharedLocationText = SWTUtil.createSingleText(group, 1); fSharedLocationText.addModifyListener(fBasicModifyListener); fSharedLocationButton = createPushButton(group, LaunchConfigurationsMessages.CommonTab__Browse_6, null); fSharedLocationButton.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent evt) { handleSharedLocationButtonSelected(); } }); fLocalRadioButton.setSelection(true); setSharedEnabled(false); } /** * Creates the component set for the capture output composite * * @param parent * the parent to add this component to */ private void test() { } private void createOutputCaptureComponent(Composite parent) { Group group = SWTUtil.createGroup(parent, "Input and Output", 1, 2, GridData.FILL_HORIZONTAL); fUseDltkRadio = createRadioButton(group, "Use DLTK Input and Output"); fUseDltkRadio.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); } }); fNotUseDltkRatio = createRadioButton(group, "Use Standard Input and Output"); fNotUseDltkRatio.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); } }); Group standardGroup = SWTUtil.createGroup(group, "", 5, 2, GridData.FILL_HORIZONTAL); fConsoleOutput = createCheckButton(standardGroup, LaunchConfigurationsMessages.CommonTab_5); GridData gd = new GridData(SWT.BEGINNING, SWT.NORMAL, true, false); gd.horizontalSpan = 5; fConsoleOutput.setLayoutData(gd); fConsoleOutput.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); } }); fFileOutput = createCheckButton(standardGroup, LaunchConfigurationsMessages.CommonTab_6); fFileOutput.setLayoutData(new GridData(SWT.BEGINNING, SWT.NORMAL, false, false)); fFileOutput.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { enableOuputCaptureWidgets(fFileOutput.getSelection()); updateLaunchConfigurationDialog(); } }); fFileText = SWTUtil.createSingleText(standardGroup, 4); fFileText.addModifyListener(fBasicModifyListener); SWTUtil.createLabel(standardGroup, EMPTY_STRING, 2); fWorkspaceBrowse = createPushButton(standardGroup, LaunchConfigurationsMessages.CommonTab_12, null); fWorkspaceBrowse.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), new WorkbenchLabelProvider(), new WorkbenchContentProvider()); dialog.setTitle(LaunchConfigurationsMessages.CommonTab_13); dialog.setMessage(LaunchConfigurationsMessages.CommonTab_14); dialog.setInput(ResourcesPlugin.getWorkspace().getRoot()); dialog.setSorter(new ResourceSorter(ResourceSorter.NAME)); if (dialog.open() == IDialogConstants.OK_ID) { IResource resource = (IResource) dialog.getFirstResult(); String arg = resource.getFullPath().toString(); String fileLoc = VariablesPlugin.getDefault().getStringVariableManager() .generateVariableExpression("workspace_loc", arg); //$NON-NLS-1$ fFileText.setText(fileLoc); } } }); fFileBrowse = createPushButton(standardGroup, LaunchConfigurationsMessages.CommonTab_7, null); fFileBrowse.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { String filePath = fFileText.getText(); FileDialog dialog = new FileDialog(getShell(), SWT.SAVE); filePath = dialog.open(); if (filePath != null) { fFileText.setText(filePath); } } }); fVariables = createPushButton(standardGroup, LaunchConfigurationsMessages.CommonTab_9, null); fVariables.addSelectionListener(new SelectionListener() { public void widgetSelected(SelectionEvent e) { StringVariableSelectionDialog dialog = new StringVariableSelectionDialog(getShell()); dialog.open(); String variable = dialog.getVariableExpression(); if (variable != null) { fFileText.insert(variable); } } public void widgetDefaultSelected(SelectionEvent e) { } }); fAppend = createCheckButton(standardGroup, LaunchConfigurationsMessages.CommonTab_11); gd = new GridData(SWT.LEFT, SWT.TOP, true, false); gd.horizontalSpan = 4; fAppend.setLayoutData(gd); fAppend.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); } }); } /** * Enables or disables the output capture widgets based on the the specified * enablement * * @param enable * if the output capture widgets should be enabled or not * */ private void enableOuputCaptureWidgets(boolean enable) { fFileText.setEnabled(enable); fFileBrowse.setEnabled(enable); fWorkspaceBrowse.setEnabled(enable); fVariables.setEnabled(enable); fAppend.setEnabled(enable); } /** * Creates the encoding component * * @param parent * the parent to add this composite to */ private void createEncodingComponent(Composite parent) { List allEncodings = IDEEncoding.getIDEEncodings(); String defaultEncoding = WorkbenchEncoding.getWorkbenchDefaultEncoding(); Group group = SWTUtil.createGroup(parent, LaunchConfigurationsMessages.CommonTab_1, 2, 1, GridData.FILL_BOTH); fDefaultEncodingButton = createRadioButton(group, MessageFormat.format(LaunchConfigurationsMessages.CommonTab_2, new String[] { defaultEncoding })); GridData gd = new GridData(SWT.BEGINNING, SWT.NORMAL, true, false); gd.horizontalSpan = 2; fDefaultEncodingButton.setLayoutData(gd); fAltEncodingButton = createRadioButton(group, LaunchConfigurationsMessages.CommonTab_3); fAltEncodingButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING)); fEncodingCombo = new Combo(group, SWT.READ_ONLY); fEncodingCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); fEncodingCombo.setFont(parent.getFont()); String[] encodingArray = (String[]) allEncodings.toArray(new String[0]); fEncodingCombo.setItems(encodingArray); if (encodingArray.length > 0) { fEncodingCombo.select(0); } SelectionListener listener = new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); fEncodingCombo.setEnabled(fAltEncodingButton.getSelection() == true); } }; fAltEncodingButton.addSelectionListener(listener); fDefaultEncodingButton.addSelectionListener(listener); fEncodingCombo.addSelectionListener(listener); } /** * Creates the controls needed to edit the launch in background attribute of * an external tool * * @param parent * the composite to create the controls in */ protected void createLaunchInBackgroundComponent(Composite parent) { fLaunchInBackgroundButton = createCheckButton(parent, LaunchConfigurationsMessages.CommonTab_10); GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL); data.horizontalSpan = 2; fLaunchInBackgroundButton.setLayoutData(data); fLaunchInBackgroundButton.setFont(parent.getFont()); fLaunchInBackgroundButton.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); } }); } /** * handles the shared radio button being selected */ private void handleSharedRadioButtonSelected() { setSharedEnabled(isShared()); updateLaunchConfigurationDialog(); } /** * Sets the widgets for specifying that a launch configuration is to be * shared to the enable value * * @param enable * the enabled value for */ private void setSharedEnabled(boolean enable) { fSharedLocationText.setEnabled(enable); fSharedLocationButton.setEnabled(enable); } private String getDefaultSharedConfigLocation(ILaunchConfiguration config) { String path = EMPTY_STRING; try { IResource[] res = config.getMappedResources(); if (res != null) { IProject proj; for (int i = 0; i < res.length; i++) { proj = res[i].getProject(); if (proj.isAccessible()) { return proj.getFullPath().toOSString(); } } } } catch (CoreException e) { DebugUIPlugin.log(e); } return path; } /** * if the shared radio button is selected, indicating that the launch * configuration is to be shared * * @return true if the radio button is selected, false otherwise */ private boolean isShared() { return fSharedRadioButton.getSelection(); } /** * Handles the shared location button being selected */ private void handleSharedLocationButtonSelected() { String currentContainerString = fSharedLocationText.getText(); IContainer currentContainer = getContainer(currentContainerString); SharedLocationSelectionDialog dialog = new SharedLocationSelectionDialog(getShell(), currentContainer, false, LaunchConfigurationsMessages.CommonTab_Select_a_location_for_the_launch_configuration_13); dialog.showClosedProjects(false); dialog.open(); Object[] results = dialog.getResult(); if ((results != null) && (results.length > 0) && (results[0] instanceof IPath)) { IPath path = (IPath) results[0]; String containerName = path.toOSString(); fSharedLocationText.setText(containerName); } } /** * gets the container form the specified path * * @param path * the path to get the container from * @return the container for the specified path or null if one cannot be * determined */ private IContainer getContainer(String path) { Path containerPath = new Path(path); return (IContainer) getWorkspaceRoot().findMember(containerPath); } /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(org.eclipse * .debug.core.ILaunchConfiguration) */ public void initializeFrom(ILaunchConfiguration configuration) { boolean isShared = !configuration.isLocal(); fSharedRadioButton.setSelection(isShared); fLocalRadioButton.setSelection(!isShared); setSharedEnabled(isShared); fSharedLocationText.setText(getDefaultSharedConfigLocation(configuration)); if (isShared) { String containerName = EMPTY_STRING; IFile file = configuration.getFile(); if (file != null) { IContainer parent = file.getParent(); if (parent != null) { containerName = parent.getFullPath().toOSString(); } } fSharedLocationText.setText(containerName); } updateFavoritesFromConfig(configuration); updateLaunchInBackground(configuration); updateEncoding(configuration); updateConsoleOutput(configuration); } /** * Updates the console output form the local configuration * * @param configuration * the local configuration */ private void updateConsoleOutput(ILaunchConfiguration configuration) { boolean outputToConsole = true; String outputFile = null; boolean append = false; boolean dltkOutput = false; try { dltkOutput = configuration.getAttribute(ScriptLaunchConfigurationConstants.ATTR_USE_INTERACTIVE_CONSOLE, false); outputToConsole = configuration.getAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, true); outputFile = configuration.getAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_FILE, (String) null); append = configuration.getAttribute(IDebugUIConstants.ATTR_APPEND_TO_FILE, false); } catch (CoreException e) { } fUseDltkRadio.setSelection(dltkOutput); fNotUseDltkRatio.setSelection(!dltkOutput); fConsoleOutput.setSelection(outputToConsole); fAppend.setSelection(append); boolean haveOutputFile = outputFile != null; if (haveOutputFile) { fFileText.setText(outputFile); } fFileOutput.setSelection(haveOutputFile); enableOuputCaptureWidgets(haveOutputFile); } /** * Updates the launch on background check button * * @param configuration * the local launch configuration */ protected void updateLaunchInBackground(ILaunchConfiguration configuration) { fLaunchInBackgroundButton.setSelection(isLaunchInBackground(configuration)); } /** * Updates the encoding * * @param configuration * the local configuration */ private void updateEncoding(ILaunchConfiguration configuration) { String encoding = null; try { encoding = configuration.getAttribute(IDebugUIConstants.ATTR_CONSOLE_ENCODING, (String) null); } catch (CoreException e) { } if (encoding != null) { fAltEncodingButton.setSelection(true); fDefaultEncodingButton.setSelection(false); fEncodingCombo.setText(encoding); fEncodingCombo.setEnabled(true); } else { fDefaultEncodingButton.setSelection(true); fAltEncodingButton.setSelection(false); fEncodingCombo.setEnabled(false); } } /** * Returns whether the given configuration should be launched in the * background. * * @param configuration * the configuration * @return whether the configuration is configured to launch in the * background */ public static boolean isLaunchInBackground(ILaunchConfiguration configuration) { boolean launchInBackground = true; try { launchInBackground = configuration.getAttribute(IDebugUIConstants.ATTR_LAUNCH_IN_BACKGROUND, true); } catch (CoreException ce) { DebugUIPlugin.log(ce); } return launchInBackground; } /** * Updates the favorites selections from the local configuration * * @param config * the local configuration */ private void updateFavoritesFromConfig(ILaunchConfiguration config) { fFavoritesTable.setInput(config); fFavoritesTable.setCheckedElements(new Object[] {}); try { List groups = config.getAttribute(IDebugUIConstants.ATTR_FAVORITE_GROUPS, new ArrayList()); if (groups.isEmpty()) { // check old attributes for backwards compatible if (config.getAttribute(IDebugUIConstants.ATTR_DEBUG_FAVORITE, false)) { groups.add(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP); } if (config.getAttribute(IDebugUIConstants.ATTR_RUN_FAVORITE, false)) { groups.add(IDebugUIConstants.ID_RUN_LAUNCH_GROUP); } } if (!groups.isEmpty()) { List list = new ArrayList(); Iterator iterator = groups.iterator(); while (iterator.hasNext()) { String id = (String) iterator.next(); LaunchGroupExtension extension = getLaunchConfigurationManager().getLaunchGroup(id); list.add(extension); } fFavoritesTable.setCheckedElements(list.toArray()); } } catch (CoreException e) { DebugUIPlugin.log(e); } } /** * Updates the configuration form the local shared config working copy * * @param config * the local shared config working copy */ private void updateConfigFromLocalShared(ILaunchConfigurationWorkingCopy config) { if (isShared()) { String containerPathString = fSharedLocationText.getText(); IContainer container = getContainer(containerPathString); config.setContainer(container); } else { config.setContainer(null); } } /** * Convenience accessor */ protected LaunchConfigurationManager getLaunchConfigurationManager() { return DebugUIPlugin.getDefault().getLaunchConfigurationManager(); } /** * Update the favorite settings. * * NOTE: set to <code>null</code> instead of <code>false</code> for * backwards compatibility when comparing if content is equal, since 'false' * is default and will be missing for older configurations. */ private void updateConfigFromFavorites(ILaunchConfigurationWorkingCopy config) { try { Object[] checked = fFavoritesTable.getCheckedElements(); boolean debug = config.getAttribute(IDebugUIConstants.ATTR_DEBUG_FAVORITE, false); boolean run = config.getAttribute(IDebugUIConstants.ATTR_RUN_FAVORITE, false); if (debug || run) { // old attributes List groups = new ArrayList(); int num = 0; if (debug) { groups.add(getLaunchConfigurationManager() .getLaunchGroup(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP)); num++; } if (run) { num++; groups.add(getLaunchConfigurationManager() .getLaunchGroup(IDebugUIConstants.ID_DEBUG_LAUNCH_GROUP)); } // see if there are any changes if (num == checked.length) { boolean different = false; for (int i = 0; i < checked.length; i++) { if (!groups.contains(checked[i])) { different = true; break; } } if (!different) { return; } } } config.setAttribute(IDebugUIConstants.ATTR_DEBUG_FAVORITE, (String) null); config.setAttribute(IDebugUIConstants.ATTR_RUN_FAVORITE, (String) null); List groups = null; for (int i = 0; i < checked.length; i++) { LaunchGroupExtension group = (LaunchGroupExtension) checked[i]; if (groups == null) { groups = new ArrayList(); } groups.add(group.getIdentifier()); } config.setAttribute(IDebugUIConstants.ATTR_FAVORITE_GROUPS, groups); } catch (CoreException e) { DebugUIPlugin.log(e); } } /** * Convenience method for getting the workspace root. */ private IWorkspaceRoot getWorkspaceRoot() { return ResourcesPlugin.getWorkspace().getRoot(); } /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#isValid(org.eclipse.debug * .core.ILaunchConfiguration) */ public boolean isValid(ILaunchConfiguration config) { setMessage(null); setErrorMessage(null); return validateLocalShared() && validateRedirectFile() && validateEncoding(); } /** * validates the encoding selection * * @return true if the validate encoding is allowable, false otherwise */ private boolean validateEncoding() { if (fAltEncodingButton.getSelection()) { if (fEncodingCombo.getSelectionIndex() == -1) { setErrorMessage("Encoding not supported."); return false; } } return true; } /** * Validates if the redirect file is valid * * @return true if the filename is not zero, false otherwise */ private boolean validateRedirectFile() { if (fFileOutput.getSelection()) { int len = fFileText.getText().trim().length(); if (len == 0) { setErrorMessage(LaunchConfigurationsMessages.CommonTab_8); return false; } } return true; } /** * validates the local shared config file location * * @return true if the local shared file exists, false otherwise */ private boolean validateLocalShared() { if (isShared()) { String path = fSharedLocationText.getText().trim(); IContainer container = getContainer(path); if (container == null || container.equals(ResourcesPlugin.getWorkspace().getRoot())) { setErrorMessage(LaunchConfigurationsMessages.CommonTab_Invalid_shared_configuration_location_14); return false; } else if (!container.getProject().isOpen()) { setErrorMessage( LaunchConfigurationsMessages.CommonTab_Cannot_save_launch_configuration_in_a_closed_project__1); return false; } } return true; } /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#setDefaults(org.eclipse. * debug.core.ILaunchConfigurationWorkingCopy) */ public void setDefaults(ILaunchConfigurationWorkingCopy config) { config.setContainer(null); config.setAttribute(IDebugUIConstants.ATTR_LAUNCH_IN_BACKGROUND, true); } /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse * .debug.core.ILaunchConfigurationWorkingCopy) */ public void performApply(ILaunchConfigurationWorkingCopy configuration) { updateConfigFromLocalShared(configuration); updateConfigFromFavorites(configuration); setAttribute(IDebugUIConstants.ATTR_LAUNCH_IN_BACKGROUND, configuration, fLaunchInBackgroundButton.getSelection(), true); String encoding = null; if (fAltEncodingButton.getSelection()) { encoding = fEncodingCombo.getText(); } configuration.setAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING, encoding); boolean captureOutput = false; if (fConsoleOutput.getSelection()) { captureOutput = true; configuration.setAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, (String) null); configuration.setAttribute(ScriptLaunchConfigurationConstants.ATTR_DLTK_CONSOLE_ID, Long.toString(System.currentTimeMillis())); } else { configuration.setAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, false); } if (fFileOutput.getSelection()) { captureOutput = true; String file = fFileText.getText(); configuration.setAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_FILE, file); if (fAppend.getSelection()) { configuration.setAttribute(IDebugUIConstants.ATTR_APPEND_TO_FILE, true); } else { configuration.setAttribute(IDebugUIConstants.ATTR_APPEND_TO_FILE, (String) null); } } else { configuration.setAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_FILE, (String) null); } boolean useDltk = false; if (fUseDltkRadio.getSelection()) { configuration.setAttribute(DebugPlugin.ATTR_CAPTURE_OUTPUT, (String) null); IFileHandle proxyFile; try { IExecutionEnvironment exeEnv = (IExecutionEnvironment) EnvironmentManager.getLocalEnvironment() .getAdapter(IExecutionEnvironment.class); proxyFile = FormulaLauncherPlugin.getDefault().getConsoleProxy(exeEnv); if (proxyFile != null) { configuration.setAttribute("environmentId", proxyFile.getEnvironment().getId()); configuration.setAttribute("proxy_path", proxyFile.toOSString()); } } catch (IOException e) { if (DLTKCore.DEBUG) { e.printStackTrace(); } } captureOutput = false; useDltk = true; } configuration.setAttribute(ScriptLaunchConfigurationConstants.ATTR_USE_INTERACTIVE_CONSOLE, useDltk); // Last option if (captureOutput) { configuration.setAttribute(DebugPlugin.ATTR_CAPTURE_OUTPUT, (String) null); } else { configuration.setAttribute(DebugPlugin.ATTR_CAPTURE_OUTPUT, false); } } /* * (non-Javadoc) * * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName() */ public String getName() { return LaunchConfigurationsMessages.CommonTab__Common_15; } /* * (non-Javadoc) * * @see org.eclipse.debug.ui.ILaunchConfigurationTab#canSave() */ public boolean canSave() { return validateLocalShared(); } /* * (non-Javadoc) * * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getImage() */ public Image getImage() { return DebugUITools.getImage(IInternalDebugUIConstants.IMG_OBJS_COMMON_TAB); } /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#activated(org.eclipse.debug * .core.ILaunchConfigurationWorkingCopy) */ public void activated(ILaunchConfigurationWorkingCopy workingCopy) { } /* * (non-Javadoc) * * @see * org.eclipse.debug.ui.ILaunchConfigurationTab#deactivated(org.eclipse. * debug.core.ILaunchConfigurationWorkingCopy) */ public void deactivated(ILaunchConfigurationWorkingCopy workingCopy) { } /** * Content provider for the favorites table */ class FavoritesContentProvider implements IStructuredContentProvider { public Object[] getElements(Object inputElement) { ILaunchGroup[] groups = DebugUITools.getLaunchGroups(); List possibleGroups = new ArrayList(); ILaunchConfiguration configuration = (ILaunchConfiguration) inputElement; for (int i = 0; i < groups.length; i++) { ILaunchGroup extension = groups[i]; LaunchHistory history = getLaunchConfigurationManager().getLaunchHistory(extension.getIdentifier()); if (history != null && history.accepts(configuration)) { possibleGroups.add(extension); } } return possibleGroups.toArray(); } public void dispose() { } public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { } } /** * Provides the labels for the favorites table * */ class FavoritesLabelProvider implements ITableLabelProvider { private Map fImages = new HashMap(); public Image getColumnImage(Object element, int columnIndex) { Image image = (Image) fImages.get(element); if (image == null) { ImageDescriptor descriptor = ((LaunchGroupExtension) element).getImageDescriptor(); if (descriptor != null) { image = descriptor.createImage(); fImages.put(element, image); } } return image; } public String getColumnText(Object element, int columnIndex) { String label = ((LaunchGroupExtension) element).getLabel(); return DebugUIPlugin.removeAccelerators(label); } public void addListener(ILabelProviderListener listener) { } public void dispose() { Iterator images = fImages.values().iterator(); while (images.hasNext()) { Image image = (Image) images.next(); image.dispose(); } } public boolean isLabelProperty(Object element, String property) { return false; } public void removeListener(ILabelProviderListener listener) { } } }