org.eclipse.ant.internal.ui.datatransfer.AntBuildfileExportPage.java Source code

Java tutorial

Introduction

Here is the source code for org.eclipse.ant.internal.ui.datatransfer.AntBuildfileExportPage.java

Source

/*******************************************************************************
 * Copyright (c) 2004, 2013 Richard Hoefter 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:
 *     Richard Hoefter (richard.hoefter@web.de) - initial API and implementation, bug 95296, bug 288830
 *     IBM Corporation - adapted to wizard export page
 *******************************************************************************/

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

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;

import org.eclipse.ant.internal.ui.AntUIPlugin;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubMonitor;
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.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.wizard.WizardPage;
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.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.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;

import com.ibm.icu.text.MessageFormat;

public class AntBuildfileExportPage extends WizardPage {

    private CheckboxTableViewer fTableViewer;
    private List<IJavaProject> fSelectedJavaProjects = new ArrayList<>();
    private Button compatibilityCheckbox;
    private Button compilerCheckbox;
    private Text buildfilenameText;
    private Text junitdirText;

    public AntBuildfileExportPage() {
        super("AntBuildfileExportWizardPage"); //$NON-NLS-1$
        setPageComplete(false);
        setTitle(DataTransferMessages.AntBuildfileExportPage_0);
        setDescription(DataTransferMessages.AntBuildfileExportPage_1);
    }

    /*
     * @see IDialogPage#createControl(Composite)
     */
    @Override
    public void createControl(Composite parent) {

        initializeDialogUnits(parent);

        Composite workArea = new Composite(parent, SWT.NONE);
        setControl(workArea);

        workArea.setLayout(new GridLayout());
        workArea.setLayoutData(
                new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL));

        Label titel = new Label(workArea, SWT.NONE);
        titel.setText(DataTransferMessages.AntBuildfileExportPage_2);

        Composite listComposite = new Composite(workArea, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        layout.marginWidth = 0;
        layout.makeColumnsEqualWidth = false;
        listComposite.setLayout(layout);

        listComposite.setLayoutData(
                new GridData(GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL | GridData.FILL_BOTH));

        // TODO set F1 help

        Table table = new Table(listComposite, SWT.CHECK | SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
        fTableViewer = new CheckboxTableViewer(table);
        table.setLayout(new TableLayout());
        GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
        data.heightHint = 300;
        table.setLayoutData(data);
        fTableViewer.setContentProvider(new WorkbenchContentProvider() {
            @Override
            public Object[] getElements(Object element) {
                if (element instanceof IJavaProject[]) {
                    return (IJavaProject[]) element;
                }
                return null;
            }
        });
        fTableViewer.setLabelProvider(new WorkbenchLabelProvider());
        fTableViewer.addCheckStateListener(new ICheckStateListener() {
            @Override
            public void checkStateChanged(CheckStateChangedEvent event) {
                if (event.getChecked()) {
                    fSelectedJavaProjects.add((IJavaProject) event.getElement());
                } else {
                    fSelectedJavaProjects.remove(event.getElement());
                }
                updateEnablement();
            }
        });

        initializeProjects();
        createSelectionButtons(listComposite);
        createCheckboxes(workArea);
        createTextFields(workArea);
        setControl(workArea);
        updateEnablement();
        Dialog.applyDialogFont(parent);
    }

    private void createSelectionButtons(Composite composite) {

        Composite buttonsComposite = new Composite(composite, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.marginWidth = 0;
        layout.marginHeight = 0;
        buttonsComposite.setLayout(layout);

        buttonsComposite.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));

        Button selectAll = new Button(buttonsComposite, SWT.PUSH);
        selectAll.setText(DataTransferMessages.AntBuildfileExportPage_11);
        selectAll.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                for (int i = 0; i < fTableViewer.getTable().getItemCount(); i++) {
                    fSelectedJavaProjects.add((IJavaProject) fTableViewer.getElementAt(i));
                }
                fTableViewer.setAllChecked(true);
                updateEnablement();
            }
        });
        setButtonLayoutData(selectAll);

        Button deselectAll = new Button(buttonsComposite, SWT.PUSH);
        deselectAll.setText(DataTransferMessages.AntBuildfileExportPage_12);
        deselectAll.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
                fSelectedJavaProjects.clear();
                fTableViewer.setAllChecked(false);
                updateEnablement();
            }
        });
        setButtonLayoutData(deselectAll);
    }

    private void createCheckboxes(Composite composite) {

        compatibilityCheckbox = new Button(composite, SWT.CHECK);
        compatibilityCheckbox.setSelection(true);
        compatibilityCheckbox.setText(DataTransferMessages.AntBuildfileExportPage_13);
        compatibilityCheckbox.setToolTipText(DataTransferMessages.AntBuildfileExportPage_14);

        compilerCheckbox = new Button(composite, SWT.CHECK);
        compilerCheckbox.setSelection(true);
        compilerCheckbox.setText(DataTransferMessages.AntBuildfileExportPage_15);
    }

    private void createTextFields(Composite composite) {

        // buildfilename and junitdir group
        Composite containerGroup = new Composite(composite, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        containerGroup.setLayout(layout);
        containerGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL));

        // label
        Label buildfilenameLabel = new Label(containerGroup, SWT.NONE);
        buildfilenameLabel.setText(DataTransferMessages.AntBuildfileExportPage_16);

        // text field
        buildfilenameText = new Text(containerGroup, SWT.SINGLE | SWT.BORDER);
        buildfilenameText.setText("build.xml"); //$NON-NLS-1$
        GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
        buildfilenameText.setLayoutData(data);

        // label
        Label junitdirLabel = new Label(containerGroup, SWT.NONE);
        junitdirLabel.setText(DataTransferMessages.AntBuildfileExportPage_17);

        // text field
        junitdirText = new Text(containerGroup, SWT.SINGLE | SWT.BORDER);
        junitdirText.setText("junit"); //$NON-NLS-1$
        junitdirText.setLayoutData(data);

        ModifyListener listener = new ModifyListener() {
            @Override
            public void modifyText(ModifyEvent e) {
                updateEnablement();
            }
        };
        buildfilenameText.addModifyListener(listener);
        junitdirText.addModifyListener(listener);
    }

    private void initializeProjects() {
        IWorkspaceRoot rootWorkspace = ResourcesPlugin.getWorkspace().getRoot();
        IJavaModel javaModel = JavaCore.create(rootWorkspace);
        IJavaProject[] javaProjects;
        try {
            javaProjects = javaModel.getJavaProjects();
        } catch (JavaModelException e) {
            javaProjects = new IJavaProject[0];
        }
        fTableViewer.setInput(javaProjects);
        // Check any necessary projects
        if (fSelectedJavaProjects != null) {
            fTableViewer.setCheckedElements(
                    fSelectedJavaProjects.toArray(new IJavaProject[fSelectedJavaProjects.size()]));
        }
    }

    private void updateEnablement() {
        boolean complete = true;
        if (fSelectedJavaProjects.size() == 0) {
            setErrorMessage(DataTransferMessages.AntBuildfileExportPage_18);
            complete = false;
        }
        try {
            List<String> projectsWithErrors = new ArrayList<>();
            List<String> projectsWithWarnings = new ArrayList<>();
            findCyclicProjects(getProjects(false), projectsWithErrors, projectsWithWarnings);
            if (projectsWithErrors.size() > 0) {
                String message = DataTransferMessages.AntBuildfileExportPage_cycle_error_in_projects;
                if (projectsWithErrors.size() == 1) {
                    message = DataTransferMessages.AntBuildfileExportPage_cycle_error_in_project;
                }
                setErrorMessage(MessageFormat.format(message,
                        new Object[] { ExportUtil.toString(projectsWithErrors, ", ") })); //$NON-NLS-1$
                complete = false;
            } else if (projectsWithWarnings.size() > 0) {
                String message = DataTransferMessages.AntBuildfileExportPage_cycle_warning_in_projects;
                if (projectsWithWarnings.size() == 1) {
                    message = DataTransferMessages.AntBuildfileExportPage_cycle_warning_in_project;
                }
                setMessage(MessageFormat.format(message,
                        new Object[] { ExportUtil.toString(projectsWithWarnings, ", ") }), WARNING); //$NON-NLS-1$
            } else {
                setMessage(null);
            }
        } catch (CoreException e) {
            // do nothing
        }
        if (buildfilenameText.getText().length() == 0) {
            setErrorMessage(DataTransferMessages.AntBuildfileExportPage_19);
            complete = false;
        }
        if (junitdirText.getText().length() == 0) {
            setErrorMessage(DataTransferMessages.AntBuildfileExportPage_20);
            complete = false;
        }
        if (complete) {
            setErrorMessage(null);
        }
        setPageComplete(complete);
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
     */
    @Override
    public void setVisible(boolean visible) {
        super.setVisible(visible);
        if (visible) {
            fTableViewer.getTable().setFocus();
        }
    }

    protected void setSelectedProjects(List<IJavaProject> selectedJavaProjects) {
        fSelectedJavaProjects.addAll(selectedJavaProjects);
    }

    /**
     * Convert Eclipse Java projects to Ant build files. Displays error dialogs.
     */
    public boolean generateBuildfiles() {
        setErrorMessage(null);
        final List<String> projectNames = new ArrayList<>();
        final Set<IJavaProject> projects;
        try {
            projects = getProjects(true);
            if (projects.size() == 0) {
                return false;
            }
        } catch (JavaModelException e) {
            AntUIPlugin.log(e);
            setErrorMessage(MessageFormat.format(DataTransferMessages.AntBuildfileExportPage_10,
                    new Object[] { e.toString() }));
            return false;
        }
        IRunnableWithProgress runnable = new IRunnableWithProgress() {
            @Override
            public void run(IProgressMonitor pm) throws InterruptedException {
                SubMonitor localmonitor = SubMonitor.convert(pm,
                        DataTransferMessages.AntBuildfileExportPage_creating_build_files, projects.size());
                Exception problem = null;
                try {
                    BuildFileCreator.setOptions(buildfilenameText.getText(), junitdirText.getText(),
                            compatibilityCheckbox.getSelection(), compilerCheckbox.getSelection());
                    projectNames.addAll(BuildFileCreator.createBuildFiles(projects, getShell(),
                            localmonitor.newChild(projects.size())));
                } catch (JavaModelException e) {
                    problem = e;
                } catch (TransformerConfigurationException e) {
                    problem = e;
                } catch (ParserConfigurationException e) {
                    problem = e;
                } catch (TransformerException e) {
                    problem = e;
                } catch (IOException e) {
                    problem = e;
                } catch (CoreException e) {
                    problem = e;
                }

                if (problem != null) {
                    AntUIPlugin.log(problem);
                    setErrorMessage(MessageFormat.format(DataTransferMessages.AntBuildfileExportPage_10,
                            new Object[] { problem.toString() }));
                }
            }
        };

        try {
            getContainer().run(false, false, runnable);
        } catch (InvocationTargetException e) {
            AntUIPlugin.log(e);
            return false;
        } catch (InterruptedException e) {
            AntUIPlugin.log(e);
            return false;
        }
        if (getErrorMessage() != null) {
            return false;
        }
        return true;
    }

    /**
     * Get projects to write buildfiles for. Opens confirmation dialog.
     * 
     * @param displayConfirmation
     *            if set to true a dialog prompts for confirmation before overwriting files
     * @return set of project names
     */
    private Set<IJavaProject> getProjects(boolean displayConfirmation) throws JavaModelException {
        // collect all projects to create buildfiles for
        Set<IJavaProject> projects = new TreeSet<>(ExportUtil.getJavaProjectComparator());
        Iterator<IJavaProject> javaProjects = fSelectedJavaProjects.iterator();
        while (javaProjects.hasNext()) {
            IJavaProject javaProject = javaProjects.next();
            projects.addAll(ExportUtil.getClasspathProjectsRecursive(javaProject));
            projects.add(javaProject);
        }

        // confirm overwrite
        List<String> confirmOverwrite = getConfirmOverwriteSet(projects);
        if (displayConfirmation && confirmOverwrite.size() > 0) {
            String message = DataTransferMessages.AntBuildfileExportPage_3 + ExportUtil.NEWLINE
                    + ExportUtil.toString(confirmOverwrite, ExportUtil.NEWLINE);
            if (!MessageDialog.openQuestion(getShell(), DataTransferMessages.AntBuildfileExportPage_4, message)) {
                return new TreeSet<>(ExportUtil.getJavaProjectComparator());
            }
        }
        return projects;
    }

    /**
     * Splits a set of given projects into a list of projects that have cyclic dependency errors and a list of projects that have cyclic dependency
     * warnings.
     */
    private void findCyclicProjects(Set<IJavaProject> projects, List<String> errors, List<String> warnings)
            throws CoreException {
        for (Iterator<IJavaProject> iter = projects.iterator(); iter.hasNext();) {
            IJavaProject javaProject = iter.next();
            IMarker marker = ExportUtil.getCyclicDependencyMarker(javaProject);
            if (marker != null) {
                Integer severityAttr = (Integer) marker.getAttribute(IMarker.SEVERITY);
                if (severityAttr != null) {
                    switch (severityAttr.intValue()) {
                    case IMarker.SEVERITY_ERROR:
                        errors.add(javaProject.getProject().getName());
                        break;
                    case IMarker.SEVERITY_WARNING:
                        warnings.add(javaProject.getProject().getName());
                        break;
                    default:
                        break;
                    }
                }
            }
        }
    }

    /**
     * Get list of projects which have already a buildfile that was not created by the buildfile export.
     * 
     * @param javaProjects
     *            list of IJavaProject objects
     * @return set of project names
     */
    private List<String> getConfirmOverwriteSet(Set<IJavaProject> javaProjects) {
        List<String> result = new ArrayList<>(javaProjects.size());
        for (IJavaProject project : javaProjects) {
            String projectRoot = ExportUtil.getProjectRoot(project);
            if (ExportUtil.existsUserFile(projectRoot + buildfilenameText.getText())) {
                result.add(project.getProject().getName());
            }
        }
        return result;
    }
}