/*******************************************************************************
 * Copyright (c) 2008-2020 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * Contributors:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/
package org.eclipse.tcf.internal.debug.ui.launch;

import java.io.File;
import java.util.Map;

import org.eclipse.core.resources.IProject;
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.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.window.Window;
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.FileDialog;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.tcf.debug.ui.ITCFLaunchContext;
import org.eclipse.tcf.internal.debug.launch.TCFLaunchDelegate;
import org.eclipse.tcf.internal.debug.ui.Activator;
import org.eclipse.tcf.internal.debug.ui.ImageCache;
import org.eclipse.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.ui.dialogs.PreferencesUtil;

public class TCFMainTab extends AbstractLaunchConfigurationTab {

    private static final String LAUNCHING_PREFERENCE_PAGE_ID = "org.eclipse.debug.ui.LaunchingPreferencePage"; //$NON-NLS-1$

    private Text project_text;
    private Text local_program_text;
    private Text remote_program_text;
    private Text working_dir_text;
    private Button disable_build;
    private Button workspace_build;
    private Button default_dir_button;
    private Button attach_children_button;
    private Button stop_at_entry_button;
    private Button stop_at_main_button;
    private Button disconnect_on_ctx_exit;
    private Button terminal_button;
    private Button filter_button;
    private Combo build_config_combo;
    private Link workpsace_link;
    private Exception init_error;

    protected boolean isLocal() {
        return false;
    }

    public void createControl(Composite parent) {
        Composite comp = new Composite(parent, SWT.NONE);
        setControl(comp);

        GridLayout topLayout = new GridLayout();
        comp.setLayout(topLayout);

        createVerticalSpacer(comp, 1);
        createHeader(comp);
        createVerticalSpacer(comp, 1);
        createProjectGroup(comp);
        createBuildGroup(comp);
        createApplicationGroup(comp);
        createWorkingDirGroup(comp);
        createVerticalSpacer(comp, 1);
        createOptionButtons(comp, 1);
    }

    private void createHeader(Composite parent) {
        Label label = new Label(parent, SWT.NONE);
        label.setText("Launching an application requires a target that supports Processes service");
        GridData gd = new GridData();
        label.setLayoutData(gd);
    }

    private void createProjectGroup(Composite parent) {
        Group group = new Group(parent, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        group.setLayout(layout);
        group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        group.setText("Project");

        Label label = new Label(group, SWT.NONE);
        label.setText("Project Name:");
        GridData gd = new GridData();
        gd.horizontalSpan = 2;
        label.setLayoutData(gd);

        project_text = new Text(group, SWT.SINGLE | SWT.BORDER);
        gd = new GridData(GridData.FILL_HORIZONTAL);
        project_text.setLayoutData(gd);
        project_text.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent evt) {
                updateBuildConfigCombo(false, null);
                updateLaunchConfigurationDialog();
            }
        });

        Button project_button = createPushButton(group, "Browse...", null);
        project_button.addSelectionListener(new SelectionAdapter() {

            @Override
            public void widgetSelected(SelectionEvent evt) {
                handleProjectButtonSelected();
                updateLaunchConfigurationDialog();
            }
        });
    }

    private void createBuildGroup(Composite parent) {
        final Shell shell = parent.getShell();
        Group group = new Group(parent, SWT.NONE);
        GridLayout layout = new GridLayout(3, false);
        group.setLayout(layout);
        group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        group.setText("Build (if required) before launching");
        createBuildConfigCombo(group, layout.numColumns);
        disable_build = new Button(group, SWT.RADIO);
        disable_build.setText("Disable auto build");
        disable_build.setToolTipText("Requires manually building project before launching");
        disable_build.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        workspace_build = new Button(group, SWT.RADIO);
        workspace_build.setText("Use workspace settings");
        workspace_build.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        workpsace_link = new Link(group, SWT.NONE);
        workpsace_link.setText("<a>Configure Workspace Settings...</a>");
        workpsace_link.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                PreferencesUtil.createPreferenceDialogOn(
                        shell,
                        LAUNCHING_PREFERENCE_PAGE_ID,
                        null,
                        null).open();
            }
        });
    }

    protected void createBuildConfigCombo(Composite parent, int colspan) {
        Composite comp = new Composite(parent, SWT.NONE);
        GridLayout layout = new GridLayout(2, false);
        comp.setLayout(layout);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = colspan;
        comp.setLayoutData(gd);
        Label label = new Label(comp, SWT.NONE);
        label.setText("Build configuration:");
        build_config_combo = new Combo(comp, SWT.READ_ONLY | SWT.DROP_DOWN);
        build_config_combo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        build_config_combo.addSelectionListener(new SelectionListener() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                updateLaunchConfigurationDialog();
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
                updateLaunchConfigurationDialog();
            }
        });
    }

    private void createApplicationGroup(Composite parent) {
        Group group = new Group(parent, SWT.NONE);
        GridLayout layout = new GridLayout();
        group.setLayout(layout);
        group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        group.setText("Application");

        createLocalExeFileGroup(group);
        if (!isLocal()) createRemoteExeFileGroup(group);
    }

    private void createLocalExeFileGroup(Composite parent) {
        Composite comp = new Composite(parent, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.numColumns = 3;
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        comp.setLayout(layout);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        comp.setLayoutData(gd);

        Label program_label = new Label(comp, SWT.NONE);
        if (isLocal()) {
            program_label.setText("Application File Path:");
        }
        else {
            program_label.setText("Local File Path:");
        }
        gd = new GridData();
        gd.horizontalSpan = 3;
        program_label.setLayoutData(gd);

        local_program_text = new Text(comp, SWT.SINGLE | SWT.BORDER);
        local_program_text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        local_program_text.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });

        Button search_button = createPushButton(comp, "Search...", null);
        search_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                handleSearchButtonSelected();
                updateLaunchConfigurationDialog();
            }
        });

        Button browse_button = createPushButton(comp, "Browse...", null);
        browse_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                handleBinaryBrowseButtonSelected();
                updateLaunchConfigurationDialog();
            }
        });
    }

    private void createRemoteExeFileGroup(Composite parent) {
        Composite comp = new Composite(parent, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        comp.setLayout(layout);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        comp.setLayoutData(gd);

        Label program_label = new Label(comp, SWT.NONE);
        program_label.setText("Remote File Path:");
        gd = new GridData();
        gd.horizontalSpan = 3;
        program_label.setLayoutData(gd);

        remote_program_text = new Text(comp, SWT.SINGLE | SWT.BORDER);
        remote_program_text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        remote_program_text.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
    }

    private void createWorkingDirGroup(Composite comp) {
        Group group = new Group(comp, SWT.NONE);
        GridLayout layout = new GridLayout();
        group.setLayout(layout);
        group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        group.setText("Working directory");

        working_dir_text = new Text(group, SWT.SINGLE | SWT.BORDER);
        working_dir_text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        working_dir_text.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });

        default_dir_button = new Button(group, SWT.CHECK);
        default_dir_button.setText("Use default");
        default_dir_button.setLayoutData(new GridData(GridData.FILL, GridData.BEGINNING, true, false));
        default_dir_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
    }

    private void createOptionButtons(Composite parent, int col_span) {
        Composite composite = new Composite(parent, SWT.NONE);
        GridLayout terminal_layout = new GridLayout();
        terminal_layout.numColumns = 1;
        terminal_layout.marginHeight = 0;
        terminal_layout.marginWidth = 0;
        composite.setLayout(terminal_layout);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = col_span;
        composite.setLayoutData(gd);

        attach_children_button = createCheckButton(composite, "Auto-attach process children");
        attach_children_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        attach_children_button.setEnabled(true);

        stop_at_entry_button = createCheckButton(composite, "Stop at program entry");
        stop_at_entry_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        stop_at_entry_button.setEnabled(true);

        stop_at_main_button = createCheckButton(composite, "Stop at 'main'");
        stop_at_main_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        stop_at_main_button.setEnabled(true);

        disconnect_on_ctx_exit = createCheckButton(composite, "Disconnect when last debug context exits");
        disconnect_on_ctx_exit.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        disconnect_on_ctx_exit.setEnabled(true);

        terminal_button = createCheckButton(composite, "Use pseudo-terminal for process standard I/O");
        terminal_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        terminal_button.setEnabled(true);

        filter_button = createCheckButton(composite, "Hide debug contexts started by other debug sessions");
        filter_button.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent evt) {
                updateLaunchConfigurationDialog();
            }
        });
        filter_button.setEnabled(true);
    }

    @Override
    protected void updateLaunchConfigurationDialog() {
        super.updateLaunchConfigurationDialog();
        working_dir_text.setEnabled(!default_dir_button.getSelection());
    }

    protected void updateBuildConfigCombo(boolean auto, String selection) {
        int selection_index = auto ? 1 : 0;
        build_config_combo.removeAll();
        build_config_combo.add("Use Active");
        build_config_combo.add("Select Automatically");
        IProject project = getProject();
        if (project != null) {
            ITCFLaunchContext launch_context = TCFLaunchContext.getLaunchContext(project);
            if (launch_context != null) {
                Map<String,String> map = launch_context.getBuildConfigIDs(project);
                if (map != null) {
                    int cnt = 2;
                    for (String id : map.keySet()) {
                        build_config_combo.add(map.get(id));
                        if (id.equals(selection)) selection_index = cnt;
                        build_config_combo.setData(Integer.toString(cnt++), id);
                    }
                }
            }
        }
        build_config_combo.select(selection_index);
    }

    public void initializeFrom(ILaunchConfiguration config) {
        setErrorMessage(null);
        setMessage(null);
        try {
            project_text.setText(config.getAttribute(TCFLaunchDelegate.ATTR_PROJECT_NAME, ""));
            boolean auto = config.getAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_AUTO, false);
            updateBuildConfigCombo(auto, config.getAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_ID, (String)null));
            int build = TCFLaunchDelegate.BUILD_BEFORE_LAUNCH_USE_WORKSPACE_SETTING;
            build = config.getAttribute(TCFLaunchDelegate.ATTR_BUILD_BEFORE_LAUNCH, build);
            disable_build.setSelection(build == TCFLaunchDelegate.BUILD_BEFORE_LAUNCH_DISABLED);
            workspace_build.setSelection(build == TCFLaunchDelegate.BUILD_BEFORE_LAUNCH_USE_WORKSPACE_SETTING);
            local_program_text.setText(config.getAttribute(TCFLaunchDelegate.ATTR_LOCAL_PROGRAM_FILE, ""));
            if (remote_program_text != null) remote_program_text.setText(config.getAttribute(TCFLaunchDelegate.ATTR_REMOTE_PROGRAM_FILE, ""));
            working_dir_text.setText(config.getAttribute(TCFLaunchDelegate.ATTR_WORKING_DIRECTORY, ""));
            default_dir_button.setSelection(!config.hasAttribute(TCFLaunchDelegate.ATTR_WORKING_DIRECTORY));
            attach_children_button.setSelection(config.getAttribute(TCFLaunchDelegate.ATTR_ATTACH_CHILDREN, true));
            stop_at_entry_button.setSelection(config.getAttribute(TCFLaunchDelegate.ATTR_STOP_AT_ENTRY, true));
            stop_at_main_button.setSelection(config.getAttribute(TCFLaunchDelegate.ATTR_STOP_AT_MAIN, true));
            disconnect_on_ctx_exit.setSelection(config.getAttribute(TCFLaunchDelegate.ATTR_DISCONNECT_ON_CTX_EXIT, true));
            terminal_button.setSelection(config.getAttribute(TCFLaunchDelegate.ATTR_USE_TERMINAL, true));
            filter_button.setSelection(config.getAttribute(TCFLaunchDelegate.ATTR_USE_CONTEXT_FILTER, true));
            working_dir_text.setEnabled(!default_dir_button.getSelection());
        }
        catch (Exception e) {
            init_error = e;
            setErrorMessage("Cannot read launch configuration: " + e);
            Activator.log(e);
        }
    }

    private IProject getProject() {
        String name = project_text.getText().trim();
        if (name.length() == 0) return null;
        return ResourcesPlugin.getWorkspace().getRoot().getProject(name);
    }

    public void performApply(ILaunchConfigurationWorkingCopy config) {
        config.setAttribute(TCFLaunchDelegate.ATTR_PROJECT_NAME, project_text.getText());
        int config_index = build_config_combo.getSelectionIndex();
        if (config_index == 0) {
            config.removeAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_ID);
            config.removeAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_AUTO);
        }
        else if (config_index == 1) {
            config.removeAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_ID);
            config.setAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_AUTO, true);
        }
        else {
            String config_id = (String)build_config_combo.getData(Integer.toString(config_index));
            config.setAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_ID, config_id);
            config.removeAttribute(TCFLaunchDelegate.ATTR_PROJECT_BUILD_CONFIG_AUTO);
        }
        int build = TCFLaunchDelegate.BUILD_BEFORE_LAUNCH_USE_WORKSPACE_SETTING;
        if (disable_build.getSelection()) build = TCFLaunchDelegate.BUILD_BEFORE_LAUNCH_DISABLED;
        config.setAttribute(TCFLaunchDelegate.ATTR_BUILD_BEFORE_LAUNCH, build);
        config.setAttribute(TCFLaunchDelegate.ATTR_LOCAL_PROGRAM_FILE, local_program_text.getText());
        if (isLocal()) {
            config.removeAttribute(TCFLaunchDelegate.ATTR_PEER_ID);
            config.setAttribute(TCFLaunchDelegate.ATTR_RUN_LOCAL_SERVER, false);
            config.setAttribute(TCFLaunchDelegate.ATTR_RUN_LOCAL_AGENT, true);
            config.setAttribute(TCFLaunchDelegate.ATTR_USE_LOCAL_AGENT, true);
            config.removeAttribute(TCFLaunchDelegate.ATTR_REMOTE_PROGRAM_FILE);
        }
        else {
            config.setAttribute(TCFLaunchDelegate.ATTR_REMOTE_PROGRAM_FILE, remote_program_text.getText());
        }
        if (default_dir_button.getSelection()) {
            config.removeAttribute(TCFLaunchDelegate.ATTR_WORKING_DIRECTORY);
        }
        else {
            config.setAttribute(TCFLaunchDelegate.ATTR_WORKING_DIRECTORY, working_dir_text.getText());
        }
        config.setAttribute(TCFLaunchDelegate.ATTR_ATTACH_CHILDREN, attach_children_button.getSelection());
        config.setAttribute(TCFLaunchDelegate.ATTR_STOP_AT_ENTRY, stop_at_entry_button.getSelection());
        config.setAttribute(TCFLaunchDelegate.ATTR_STOP_AT_MAIN, stop_at_main_button.getSelection());
        config.setAttribute(TCFLaunchDelegate.ATTR_DISCONNECT_ON_CTX_EXIT, disconnect_on_ctx_exit.getSelection());
        config.setAttribute(TCFLaunchDelegate.ATTR_USE_TERMINAL, terminal_button.getSelection());
        if (filter_button.getSelection()) {
            config.removeAttribute(TCFLaunchDelegate.ATTR_USE_CONTEXT_FILTER);
        }
        else {
            config.setAttribute(TCFLaunchDelegate.ATTR_USE_CONTEXT_FILTER, false);
        }
    }

    /**
     * Show a dialog that lists all executable files in currently selected project.
     */
    private void handleSearchButtonSelected() {
        IProject project = getProject();
        if (project == null) {
            MessageDialog.openInformation(getShell(),
                    "Project required",
                    "Enter project before searching for program");
            return;
        }
        ITCFLaunchContext launch_context = TCFLaunchContext.getLaunchContext(project);
        if (launch_context == null) return;
        String path = launch_context.chooseBinary(getShell(), project);
        if (path != null) local_program_text.setText(path);
    }

    /**
     * Show a dialog that lets the user select a project. This in turn provides context for the main
     * type, allowing the user to key a main type name, or constraining the search for main types to
     * the specified project.
     */
    private void handleBinaryBrowseButtonSelected() {
        FileDialog file_dialog = new FileDialog(getShell(), SWT.NONE);
        file_dialog.setFileName(local_program_text.getText());
        String path = file_dialog.open();
        if (path != null) local_program_text.setText(path);
    }

    /**
     * Show a dialog that lets the user select a project. This in turn provides context for the main
     * type, allowing the user to key a main type name, or constraining the search for main types to
     * the specified project.
     */
    private void handleProjectButtonSelected() {
        try {
            IProject project = chooseProject();
            if (project == null) return;
            project_text.setText(project.getName());
        }
        catch (Exception e) {
            Activator.log("Cannot get project description", e);
        }
    }

    /**
     * Show project list dialog and return the first selected project, or null.
     */
    private IProject chooseProject() {
        try {
            IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
            ILabelProvider label_provider = new LabelProvider() {

                @Override
                public String getText(Object element) {
                    if (element == null) return "";
                    return ((IProject)element).getName();
                }
            };
            ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), label_provider);
            dialog.setTitle("Project Selection");
            dialog.setMessage("Choose project to constrain search for program");
            dialog.setElements(projects);

            IProject cProject = getProject();
            if (cProject != null) dialog.setInitialSelections(new Object[]{cProject});
            if (dialog.open() == Window.OK) return (IProject)dialog.getFirstResult();
        }
        catch (Exception e) {
            Activator.log("Cannot show project list dialog", e);
        }
        return null;
    }

    @Override
    public boolean isValid(ILaunchConfiguration config) {
        setErrorMessage(null);
        setMessage(null);

        if (init_error != null) {
            setErrorMessage("Cannot read launch configuration: " + init_error);
            return false;
        }

        String project_name = project_text.getText().trim();
        if (project_name.length() != 0) {
            IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(project_name);
            if (!project.exists()) {
                setErrorMessage("Project does not exist");
                return false;
            }
            if (!project.isOpen()) {
                setErrorMessage("Project must be opened");
                return false;
            }
        }
        String local_name = local_program_text.getText().trim();
        if (local_name.equals(".") || local_name.equals("..")) { //$NON-NLS-1$ //$NON-NLS-2$
            setErrorMessage("Invalid local program name");
            return false;
        }
        if (remote_program_text != null) {
            String remote_name = remote_program_text.getText().trim();
            if (remote_name.equals(".") || remote_name.equals("..")) { //$NON-NLS-1$ //$NON-NLS-2$
                setErrorMessage("Invalid remote program name");
                return false;
            }
        }
        if (local_name.length() > 0) {
            IProject project = getProject();
            IPath program_path = new Path(local_name);
            if (!program_path.isAbsolute()) {
                if (project == null) {
                    File ws = ResourcesPlugin.getWorkspace().getRoot().getLocation().toFile();
                    File file = new File(ws, local_name);
                    if (!file.exists()) {
                        setErrorMessage("File not found: " + file);
                        return false;
                    }
                    if (file.isDirectory()) {
                        setErrorMessage("Program path is directory name: " + file);
                        return false;
                    }
                    program_path = new Path(file.getAbsolutePath());
                }
                else if (!project.getFile(local_name).exists()) {
                    setErrorMessage("Program does not exist");
                    return false;
                }
                else {
                    program_path = project.getFile(local_name).getLocation();
                }
            }
            else {
                File file = program_path.toFile();
                if (!file.exists()) {
                    setErrorMessage("Program file does not exist");
                    return false;
                }
                if (file.isDirectory()) {
                    setErrorMessage("Program path is directory name");
                    return false;
                }
            }
            if (project != null) {
                try {
                    ITCFLaunchContext launch_context = TCFLaunchContext.getLaunchContext(project);
                    if (launch_context != null && !launch_context.isBinary(project, program_path)) {
                        setErrorMessage("Program is not a recongnized executable");
                        return false;
                    }
                }
                catch (CoreException e) {
                    Activator.log(e);
                    setErrorMessage(e.getLocalizedMessage());
                    return false;
                }
            }
        }
        return true;
    }

    public void setDefaults(ILaunchConfigurationWorkingCopy config) {
        config.setAttribute(TCFLaunchDelegate.ATTR_PROJECT_NAME, "");
        config.setAttribute(TCFLaunchDelegate.ATTR_ATTACH_CHILDREN, true);
        config.setAttribute(TCFLaunchDelegate.ATTR_STOP_AT_ENTRY, true);
        config.setAttribute(TCFLaunchDelegate.ATTR_STOP_AT_MAIN, true);
        config.setAttribute(TCFLaunchDelegate.ATTR_DISCONNECT_ON_CTX_EXIT, true);
        config.setAttribute(TCFLaunchDelegate.ATTR_USE_TERMINAL, true);
        config.removeAttribute(TCFLaunchDelegate.ATTR_USE_CONTEXT_FILTER);
        config.removeAttribute(TCFLaunchDelegate.ATTR_WORKING_DIRECTORY);
        ITCFLaunchContext launch_context = TCFLaunchContext.getLaunchContext(null);
        if (launch_context != null) launch_context.setDefaults(getLaunchConfigurationDialog(), config);
    }

    public String getName() {
        return "Application";
    }

    @Override
    public Image getImage() {
        return ImageCache.getImage(ImageCache.IMG_APPLICATION_TAB);
    }
}