org.grails.ide.eclipse.ui.internal.launch.GrailsLaunchMainTab.java Source code

Java tutorial

Introduction

Here is the source code for org.grails.ide.eclipse.ui.internal.launch.GrailsLaunchMainTab.java

Source

/*******************************************************************************
 * Copyright (c) 2012 VMWare, Inc.
 * 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
 * https://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VMWare, Inc. - initial API and implementation
 *******************************************************************************/
package org.grails.ide.eclipse.ui.internal.launch;

import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.debug.ui.launchConfigurations.JavaLaunchTab;
import org.eclipse.jdt.internal.debug.ui.launcher.LauncherMessages;
import org.eclipse.jdt.internal.launching.JavaMigrationDelegate;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jface.viewers.ILabelProvider;
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.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Font;
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.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.dialogs.ElementListSelectionDialog;
import org.grails.ide.eclipse.core.GrailsCoreActivator;
import org.grails.ide.eclipse.core.internal.GrailsNature;
import org.grails.ide.eclipse.core.launch.GrailsLaunchArgumentUtils;
import org.grails.ide.eclipse.core.model.GrailsBuildSettingsHelper;
import org.grails.ide.eclipse.core.model.IGrailsInstall;
import org.springsource.ide.eclipse.commons.core.SpringCoreUtils;

import org.grails.ide.eclipse.ui.GrailsUiImages;
import org.grails.ide.eclipse.ui.internal.inplace.GrailsCompletionUtils;

/**
 * @author Christian Dupuis
 * @since 2.2.0
 */
public class GrailsLaunchMainTab extends JavaLaunchTab {

    /**
     * A listener which handles widget change events for the controls in this tab.
     */
    private class WidgetListener implements ModifyListener, SelectionListener {

        public void modifyText(ModifyEvent e) {
            updateLaunchConfigurationDialog();
        }

        public void widgetDefaultSelected(SelectionEvent e) {/* do nothing */
        }

        public void widgetSelected(SelectionEvent e) {
            Object source = e.getSource();
            if (source == fProjButton) {
                handleProjectButtonSelected();
            } else {
                updateLaunchConfigurationDialog();
            }
        }
    }

    protected static final String EMPTY_STRING = ""; //$NON-NLS-1$

    // Project UI widgets
    protected Text fProjText;

    private Button fProjButton;

    private WidgetListener fListener = new WidgetListener();

    /**
     * chooses a project for the type of java launch config that it is
     * @return
     */
    private IJavaProject chooseJavaProject() {
        ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
        ElementListSelectionDialog dialog = new ElementListSelectionDialog(getShell(), labelProvider);
        dialog.setTitle("");
        dialog.setMessage("");
        try {
            Set<IJavaProject> projects = new LinkedHashSet<IJavaProject>();
            for (IJavaProject project : JavaCore.create(getWorkspaceRoot()).getJavaProjects()) {
                if (SpringCoreUtils.hasNature(project.getResource(), GrailsNature.NATURE_ID)) {
                    projects.add(project);
                }
            }
            dialog.setElements((IJavaProject[]) projects.toArray(new IJavaProject[projects.size()]));
        } catch (JavaModelException e) {
            GrailsCoreActivator.log(e);
        }
        IJavaProject javaProject = getJavaProject();
        if (javaProject != null) {
            dialog.setInitialSelections(new Object[] { javaProject });
        }
        if (dialog.open() == Window.OK) {
            return (IJavaProject) dialog.getFirstResult();
        }
        return null;
    }

    /**
     * Creates the widgets for specifying a main type.
     * 
     * @param parent the parent composite
     */
    protected void createProjectEditor(Composite parent) {
        Font font = parent.getFont();
        Group group = new Group(parent, SWT.NONE);
        group.setText(LauncherMessages.AbstractJavaMainTab_0);
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        group.setLayoutData(gd);
        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        group.setLayout(layout);
        group.setFont(font);
        fProjText = new Text(group, SWT.SINGLE | SWT.BORDER);
        gd = new GridData(GridData.FILL_HORIZONTAL);
        fProjText.setLayoutData(gd);
        fProjText.setFont(font);
        fProjText.addModifyListener(fListener);
        fProjText.setEditable(false);
        fProjButton = createPushButton(group, LauncherMessages.AbstractJavaMainTab_1, null);
        fProjButton.addSelectionListener(fListener);
    }

    /**
     * returns the default listener from this class. For all subclasses this listener will only provide the
     * functionality of updating the current tab
     * 
     * @return a widget listener
     */
    protected WidgetListener getDefaultListener() {
        return fListener;
    }

    /**
     * Convenience method to get access to the java model.
     */
    private IJavaModel getJavaModel() {
        return JavaCore.create(getWorkspaceRoot());
    }

    /**
     * Return the IJavaProject corresponding to the project name in the project name text field, or null if the text
     * does not match a project name.
     */
    protected IJavaProject getJavaProject() {
        String projectName = fProjText.getText().trim();
        if (projectName == null || projectName.length() < 1) {
            setErrorMessage("No project selected");
            return null;
        }
        IJavaProject javaProject = getJavaModel().getJavaProject(projectName);
        if (!javaProject.exists()) {
            setErrorMessage("Project " + projectName + " doesn't exist");
            return null;
        }
        if (!javaProject.exists()) {
            setErrorMessage("Project " + projectName + " isn't open");
            return null;
        }
        setErrorMessage(null);
        return javaProject;
    }

    /**
     * Convenience method to get the workspace root.
     */
    protected IWorkspaceRoot getWorkspaceRoot() {
        return ResourcesPlugin.getWorkspace().getRoot();
    }

    /**
     * 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.
     */
    protected void handleProjectButtonSelected() {
        IJavaProject project = chooseJavaProject();
        if (project == null) {
            return;
        }
        String projectName = project.getElementName();
        fProjText.setText(projectName);
        initializeContentAssist();
    }

    /**
     * updates the project text field form the configuration
     * @param config the configuration we are editing
     */
    private void updateProjectFromConfig(ILaunchConfiguration config) {
        String projectName = EMPTY_STRING;
        try {
            projectName = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, EMPTY_STRING);
            script.setText(config.getAttribute(GrailsCoreActivator.PLUGIN_ID + ".SCRIPT", EMPTY_STRING));
        } catch (CoreException ce) {
            setErrorMessage(ce.getStatus().getMessage());
        }
        fProjText.setText(projectName);
    }

    /**
     * Maps the config to associated java resource
     * 
     * @param config
     */
    protected void mapResources(ILaunchConfigurationWorkingCopy config) {
        try {
            // CONTEXTLAUNCHING
            IJavaProject javaProject = getJavaProject();
            if (javaProject != null && javaProject.exists() && javaProject.isOpen()) {
                JavaMigrationDelegate.updateResourceMapping(config);
            }
        } catch (CoreException ce) {
            setErrorMessage(ce.getStatus().getMessage());
        }
    }

    private Text script;

    public Image getImage() {
        return GrailsUiImages.getImage(GrailsUiImages.IMG_OBJ_GRAILS);
    }

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

        GridLayout layout = new GridLayout();
        layout.numColumns = 1;
        GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
        mainComposite.setLayout(layout);
        mainComposite.setLayoutData(gridData);
        mainComposite.setFont(parent.getFont());

        createProjectEditor(mainComposite);

        Group group = new Group(mainComposite, SWT.NONE);
        group.setText("Grails Command");
        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        group.setLayoutData(gd);
        layout = new GridLayout();
        layout.numColumns = 2;
        group.setLayout(layout);

        Label label = new Label(group, SWT.NONE);
        label.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
        label.setText("grails> ");

        script = new Text(group, SWT.BORDER);
        script.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false));
        script.addModifyListener(new ModifyListener() {

            public void modifyText(ModifyEvent e) {
                setDirty(true);
                updateLaunchConfigurationDialog();
            }
        });

        new Label(group, SWT.NONE);

        Label note = new Label(group, SWT.NONE);
        note.setLayoutData(new GridData(SWT.RIGHT, SWT.TOP, false, false));
        note.setText("Note: type command without the 'grails' prefix");
    }

    public void initializeFrom(ILaunchConfiguration configuration) {
        super.initializeFrom(configuration);
        updateProjectFromConfig(configuration);
        initializeContentAssist();
        setDirty(false);
    }

    private void initializeContentAssist() {
        if (getJavaProject() != null) {
            GrailsCompletionUtils.addTypeFieldAssistToText(script, getJavaProject().getProject());
        }
    }

    public void performApply(ILaunchConfigurationWorkingCopy configuration) {
        if (configuration == null) {
            return;
        }
        if (getJavaProject() != null) {
            IProject project = getJavaProject().getProject();
            IGrailsInstall install = GrailsCoreActivator.getDefault().getInstallManager().getGrailsInstall(project);
            try {
                GrailsLaunchArgumentUtils.prepareLaunchConfiguration(project, script.getText(), install,
                        GrailsBuildSettingsHelper.getBaseDir(project), configuration);
                configuration.doSave();
                setDirty(false);
            } catch (CoreException e) {
                GrailsCoreActivator.log(e);
            }
        }
    }

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

    public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
        configuration.setAttribute(ILaunchManager.ATTR_APPEND_ENVIRONMENT_VARIABLES, true);
        configuration.setAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES, new HashMap<String, String>());
    }
}