ProjectSelectionPage.java

/*
 * Copyright (C) 2006-2016 DLR, Germany
 * 
 * All rights reserved
 * 
 * http://www.rcenvironment.de/
 */

package de.rcenvironment.core.gui.workflow.editor;

import java.io.File;
import java.util.Arrays;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
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.Text;
import org.eclipse.swt.widgets.TreeItem;

import de.rcenvironment.core.gui.utils.incubator.AlphanumericalTextContraintListener;

/**
 * This page handles the association of a new workflow with a project. The
 * workflow can be placed in an existing project or in a project that is created
 * on the fly.
 * 
 * @author Oliver Seebach
 */
final class ProjectSelectionPage extends WizardPage {
    
    private static final char[] FORBIDDEN_CHARS = new char[] { '/', '\\', ':',
        '*', '?', '\"', '>', '<', '|' };

    private static final int TEXT_WIDTH = 100;
    private static final int TREE_HEIGHT = 200;
    private static final int TREE_WIDTH = 100;
    private static final int LIST_HEIGHT = 200;
    private static final int PANEL_HEIGHT = 250;
    private static final int DIALOGWINDOWIDTH = 500;
    private static final int BORDERSIZE = 5;

    private ProjectUsages usage;
    private TreeViewer projectTreeViewer;
    private IStructuredSelection selection;
    private Text projectNameTextField;
    private Button newProjectRadioButton;
    private Button existingProjectRadioButton;
    private Button useDefaultNameButton;
    private String workflowName;

    ProjectSelectionPage(final NewWorkflowProjectWizard parentWizard,
            final IStructuredSelection selection) {
        super("Project");
        this.selection = selection;
        setTitle("Project");
        setDescription("Place the workflow in a project");
    }

    private void dialogChanged() {
        final String newProjectName = getProjectNameTextField().getText();
        if (newProjectName.length() == 0
                && newProjectRadioButton.getSelection()) {
            updateStatus("Please chose a name for the new project");
            return;
        }

        if (newProjectName.length() > 0) {
            IProject existingProject = ResourcesPlugin.getWorkspace().getRoot()
                    .getProject(newProjectName);
            if (existingProject != null && existingProject.exists()
                    && newProjectRadioButton.getSelection()) {
                updateStatus("This project name is already in use");
                return;
            }
        }

        updateStatus(null);
    }

    private void updateStatus(String message) {
        setErrorMessage(message);
        if (message == null) {
            NewWorkflowProjectWizard.allowFinish();
        } else {
            NewWorkflowProjectWizard.preventFinish();
        }
        setPageComplete(message == null);
    }

    private void createExistingProjectPanel(Composite parent) {
        // ------------------
        // EXISTING PROJECT STUFF
        // ------------------

        GridLayout existingGrid = new GridLayout(1, false);
        // composite
        GridData existingGridDataComp = new GridData();
        existingGridDataComp.widthHint = (DIALOGWINDOWIDTH / 2) - BORDERSIZE;
        existingGridDataComp.heightHint = PANEL_HEIGHT;
        existingGridDataComp.verticalAlignment = GridData.BEGINNING;
        existingGridDataComp.horizontalAlignment = GridData.BEGINNING;
        existingGridDataComp.grabExcessVerticalSpace = true;
        // radiobutton
        GridData existingGridDataRadio = new GridData();
        existingGridDataRadio.widthHint = (DIALOGWINDOWIDTH / 2) - 2
                * BORDERSIZE;
        existingGridDataRadio.verticalAlignment = GridData.BEGINNING;
        existingGridDataRadio.horizontalAlignment = GridData.BEGINNING;
        existingGridDataRadio.grabExcessVerticalSpace = true;
        // list
        GridData existingGridDataList = new GridData();
        existingGridDataList.widthHint = (DIALOGWINDOWIDTH / 2) - 7
                * BORDERSIZE;
        existingGridDataList.heightHint = LIST_HEIGHT;
        existingGridDataList.verticalAlignment = GridData.BEGINNING;
        existingGridDataList.horizontalAlignment = GridData.BEGINNING;
        existingGridDataList.grabExcessVerticalSpace = true;
        existingGridDataList.grabExcessHorizontalSpace = true;

        Composite existingProjectComposite = new Composite(parent, SWT.BORDER);
        existingProjectComposite.setLayout(existingGrid);
        existingProjectComposite.setLayoutData(existingGridDataComp);

        setExistingProjectRadioButton(new Button(existingProjectComposite,
                SWT.RADIO));
        getExistingProjectRadioButton().setText("Place in existing project");
        getExistingProjectRadioButton().setVisible(true);
        getExistingProjectRadioButton().setLayoutData(existingGridDataRadio);

        projectTreeViewer = new TreeViewer(existingProjectComposite, SWT.SINGLE
                | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);

        projectTreeViewer.setContentProvider(new ProjectTreeContentProvider());
        projectTreeViewer.setLabelProvider(new ProjectTreeLabelProvider());

        projectTreeViewer.setInput(File.listRoots());
        projectTreeViewer.getTree().setSize(TREE_WIDTH, TREE_HEIGHT);
        projectTreeViewer.getTree().setLayoutData(existingGridDataList);

        setControl(existingProjectComposite);
    }

    private void createNewProjectPanel(Composite parent) {
        // ------------------
        // NEW PROJECT STUFF
        // ------------------

        GridLayout newGrid = new GridLayout(1, false);
        GridData newGridDataComp = new GridData();
        newGridDataComp.widthHint = (DIALOGWINDOWIDTH / 2) - BORDERSIZE;
        newGridDataComp.heightHint = PANEL_HEIGHT;
        newGridDataComp.verticalAlignment = GridData.BEGINNING;
        newGridDataComp.horizontalAlignment = GridData.BEGINNING;
        newGridDataComp.grabExcessVerticalSpace = false;

        GridData newGridDataRadio = new GridData();
        newGridDataRadio.widthHint = (DIALOGWINDOWIDTH / 2) - BORDERSIZE;
        newGridDataRadio.verticalAlignment = GridData.BEGINNING;
        newGridDataRadio.horizontalAlignment = GridData.BEGINNING;

        GridData newGridDataCheck = new GridData();
        newGridDataCheck.widthHint = (DIALOGWINDOWIDTH / 2) - BORDERSIZE;
        newGridDataCheck.verticalAlignment = GridData.BEGINNING;
        newGridDataCheck.horizontalAlignment = GridData.BEGINNING;

        GridData newGridDataLabel = new GridData();
        newGridDataLabel.widthHint = (DIALOGWINDOWIDTH / 2) - BORDERSIZE;
        newGridDataLabel.verticalAlignment = GridData.BEGINNING;
        newGridDataLabel.horizontalAlignment = GridData.BEGINNING;

        GridData newGridDataText = new GridData();
        newGridDataText.widthHint = (DIALOGWINDOWIDTH / 2) - 10 * BORDERSIZE;
        newGridDataText.minimumWidth = TEXT_WIDTH;
        newGridDataText.verticalAlignment = GridData.BEGINNING;
        newGridDataText.horizontalAlignment = GridData.BEGINNING;
        newGridDataText.grabExcessHorizontalSpace = true;

        Composite newProjectComposite = new Composite(parent, SWT.BORDER);
        newProjectComposite.setLayout(newGrid);
        newProjectComposite.setLayoutData(newGridDataComp);

        setNewProjectRadioButton(new Button(newProjectComposite, SWT.RADIO));
        getNewProjectRadioButton().setText("Place in new project");
        getNewProjectRadioButton().setLayoutData(newGridDataRadio);
        getNewProjectRadioButton().setVisible(true);
        if (ResourcesPlugin.getWorkspace().getRoot().getProjects().length > 0) {
            getNewProjectRadioButton().setSelection(false);
            getExistingProjectRadioButton().setSelection(true);
            setUsage(ProjectUsages.EXISTING);
        } else {
            getNewProjectRadioButton().setSelection(true);
            getExistingProjectRadioButton().setSelection(false);
            setUsage(ProjectUsages.NEW);
        }

        useDefaultNameButton = new Button(newProjectComposite, SWT.CHECK);
        useDefaultNameButton.setSelection(true);
        useDefaultNameButton.setText("Use default project name");
        useDefaultNameButton.setEnabled(getNewProjectRadioButton()
                .getSelection());
        useDefaultNameButton.setVisible(true);
        useDefaultNameButton.setLayoutData(newGridDataCheck);

        Label projectNameLabel = new Label(newProjectComposite, SWT.NONE);
        projectNameLabel.setText("Project name: ");
        projectNameLabel.setVisible(true);
        projectNameLabel.setLayoutData(newGridDataLabel);

        setProjectNameTextField(new Text(newProjectComposite, SWT.SINGLE
                | SWT.BORDER));
        projectNameTextField.setEnabled(false);
        projectNameTextField.setVisible(true);
        projectNameTextField.setLayoutData(newGridDataText);
        projectNameTextField.addListener(SWT.Verify, new AlphanumericalTextContraintListener(false, true));
        projectNameTextField.addListener(SWT.Verify, new AlphanumericalTextContraintListener(FORBIDDEN_CHARS));
        projectNameTextField.addModifyListener(new ModifyListener() {

            @Override
            public void modifyText(ModifyEvent arg0) {
                dialogChanged();
            }
        });
        if (NewWorkflowProjectWizard.sharedWorkflowName != null){
            projectNameTextField.setText(NewWorkflowProjectWizard.sharedWorkflowName);
        }

        setControl(newProjectComposite);
    }

    @Override
    public void createControl(Composite parent) {

        Composite comp = new Composite(parent, SWT.NONE);
        comp.setLayout(new GridLayout(2, false));

        // create gui and register listeners
        createExistingProjectPanel(comp);
        createNewProjectPanel(comp);
        registerListeners();
        handleInitialTreeSelection();





    }

    private void handleInitialTreeSelection() {
        boolean useExistingProject = false;
        
        if (this.selection != null) {
            useExistingProject = true;
            if (this.selection.getFirstElement() != null) {
                useExistingProject = true;
            } else {
                useExistingProject = false;
            }
        }
        
        if (useExistingProject) {
            if (this.selection.size() == 1
                    && this.selection.getFirstElement() instanceof IProject) {
                // (a) Project selected
                projectTreeViewer.setSelection(selection);
                getExistingProjectRadioButton().setSelection(true);
                getNewProjectRadioButton().setSelection(false);
            } else if (this.selection.size() == 1
                    && this.selection.getFirstElement() instanceof IFolder) {
                // (b) Folder selected
                IFolder folder = (IFolder) this.selection.getFirstElement();
                String pathToExpand2 = folder.getFullPath().toOSString()
                        .substring(1);
                java.util.List<String> pathToExpand = Arrays
                        .asList(pathToExpand2.split("\\\\"));
                TreeItem[] currentCandidates = projectTreeViewer.getTree()
                        .getItems();
                TreeItem lastItem = null;
                for (String segment : pathToExpand) {
                    TreeItem matchedItem = null;
                    for (TreeItem item : currentCandidates) {
                        if (item.getText().equals(segment)) {
                            item.setExpanded(true);
                            matchedItem = item;
                            projectTreeViewer.refresh();
                            break;
                        }
                    }
                    if (matchedItem != null) {
                        currentCandidates = matchedItem.getItems();
                        lastItem = matchedItem;
                    }
                }
                if (lastItem != null) {
                    projectTreeViewer.getTree().setSelection(lastItem);
                }
                projectTreeViewer.refresh();
                getExistingProjectRadioButton().setSelection(true);
                getNewProjectRadioButton().setSelection(false);
            } else if (this.selection.size() == 1
                    && this.selection.getFirstElement() instanceof IFile) {
                // (c) File selected
                IFile file = (IFile) this.selection.getFirstElement();
                IStructuredSelection iss = new StructuredSelection(
                        file.getProject());
                projectTreeViewer.setSelection(iss);
                getExistingProjectRadioButton().setSelection(true);
                getNewProjectRadioButton().setSelection(false);
            } else {
                // None of this selected, but selection not null (e.g.
                // WorkflowPart counts as not null)
                activateExistingProjectPart();
            }
        } else {
            // Selection null (e.g. Focus on ProjectExplorer counts as selection
            // null)
            activateExistingProjectPart();
        }
        
        // in case workspace contains no projects so far
        if (projectTreeViewer.getTree().getItemCount() == 0) {
            getExistingProjectRadioButton().setEnabled(false);
            projectTreeViewer.getTree().setEnabled(false);
            getNewProjectRadioButton().setSelection(true);
        }
    }

    private void registerListeners() {
        newProjectRadioButton.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent arg0) {
                if (getNewProjectRadioButton().getSelection()) {
                    if (NewWorkflowProjectWizard.sharedWorkflowName != null){
                        getProjectNameTextField().setText(NewWorkflowProjectWizard.sharedWorkflowName);
                    }
                    useDefaultNameButton.setEnabled(true);
                    getExistingProjectRadioButton().setSelection(false);
                    projectTreeViewer.getTree().setEnabled(false);
                    setUsage(ProjectUsages.NEW);
                    dialogChanged();
                }
            }
        });

        existingProjectRadioButton.addSelectionListener(
                new SelectionAdapter() {

                    @Override
                    public void widgetSelected(SelectionEvent arg0) {
                        getNewProjectRadioButton().setSelection(false);
                        useDefaultNameButton.setEnabled(false);
                        projectTreeViewer.getTree().setEnabled(true);
                        if (projectTreeViewer.getTree().getSelection().length == 0) {
                            projectTreeViewer.getTree().setSelection(
                                    projectTreeViewer.getTree().getItem(0));
                        }
                        NewWorkflowProjectWizard.setWorkbenchSelection(new StructuredSelection(
                                projectTreeViewer.getSelection()));
                        setUsage(ProjectUsages.EXISTING);
                        dialogChanged();
                    }
                });

        useDefaultNameButton.addSelectionListener(new SelectionAdapter() {

            @Override
            public void widgetSelected(SelectionEvent arg0) {
                // if checked -> enabled+editable , else -> disable+non-editable
                boolean selectionState = useDefaultNameButton.getSelection();
                getProjectNameTextField().setEditable(!selectionState);
                getProjectNameTextField().setEnabled(!selectionState);
            }
        });

        projectTreeViewer
                .addSelectionChangedListener(new ISelectionChangedListener() {
                    @Override
                    public void selectionChanged(SelectionChangedEvent event) {
                        NewWorkflowProjectWizard.setWorkbenchSelection((IStructuredSelection) event.getSelection());
                    }
                });
    }

    private void activateExistingProjectPart() {
        getNewProjectRadioButton().setSelection(true);
        getExistingProjectRadioButton().setSelection(false);
        if (workflowName != null){
            getProjectNameTextField().setText(workflowName);
        }
    }

    public Text getProjectNameTextField() {
        return projectNameTextField;
    }

    public void setProjectNameTextField(Text projectNameTextField) {
        this.projectNameTextField = projectNameTextField;
    }

    public ProjectUsages getUsage() {
        return usage;
    }

    public void setUsage(ProjectUsages usage) {
        this.usage = usage;
    }

    public Button getNewProjectRadioButton() {
        return newProjectRadioButton;
    }

    public void setNewProjectRadioButton(Button newProjectRadioButton) {
        this.newProjectRadioButton = newProjectRadioButton;
    }

    public Button getExistingProjectRadioButton() {
        return existingProjectRadioButton;
    }

    public void setExistingProjectRadioButton(Button existingProjectRadioButton) {
        this.existingProjectRadioButton = existingProjectRadioButton;
    }
}