com.siteview.mde.internal.ui.nls.InternationalizeWizardPluginPage.java Source code

Java tutorial

Introduction

Here is the source code for com.siteview.mde.internal.ui.nls.InternationalizeWizardPluginPage.java

Source

/*******************************************************************************
 * Copyright (c) 2008 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package com.siteview.mde.internal.ui.nls;

import com.siteview.mde.core.monitor.*;

import java.util.*;
import java.util.List;
import org.eclipse.core.runtime.*;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.osgi.util.NLS;
import com.siteview.mde.core.IModelProviderEvent;
import com.siteview.mde.core.IModelProviderListener;
import com.siteview.mde.internal.core.ClasspathUtilCore;
import com.siteview.mde.internal.core.MDECore;
import com.siteview.mde.internal.ui.MDEPlugin;
import com.siteview.mde.internal.ui.MDEUIMessages;
import com.siteview.mde.internal.ui.elements.DefaultContentProvider;
import com.siteview.mde.internal.ui.util.SWTUtil;
import com.siteview.mde.internal.ui.wizards.ListUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;
import org.eclipse.ui.progress.WorkbenchJob;

/**
 * The first page of the InternationalizeWizard. This page allows the user to 
 * select the desired plug-ins for internationalization. These could be plug-ins
 * in the user's workspace or external ones.
 */
public class InternationalizeWizardPluginPage extends InternationalizationWizardPage
        implements IModelProviderListener {

    private static final String CREATE_INDIVIDUAL_FRAGMENTS = "create individual fragments"; //$NON-NLS-1$
    private static final String TEMPLATE = "name_template"; //$NON-NLS-1$
    private static final String OVERWRITE = "overwrite?"; //$NON-NLS-1$
    public static final String PAGE_NAME = "InternationalizeWizardPluginPage"; //$NON-NLS-1$

    protected IMonitorModelBase[] fModels = new IMonitorModelBase[0];

    private boolean fRefreshNeeded = true;

    private Label fCountLabel; //Displays "x out of y selected"

    private TableViewer fAvailableViewer; //All available plug-ins
    protected TableViewer fSelectedViewer; //Selected plug-ins

    private WorkbenchJob fFilterJob;
    private Text fFilterText;
    private Text fTemplateText;
    private AvailableFilter fFilter;

    // Used to track the selection in a HashMap so as to filter
    // selected items out of the available item list
    private final Map fSelected = new HashMap();

    // Used to block the selection listeners from updating button enablement
    // when programatically removing items
    private boolean fBlockSelectionListeners;
    private Button fAddButton;
    private Button fAddAllButton;
    private Button fRemoveButton;
    private Button fRemoveAllButton;

    // Used to store the plug-ins
    private InternationalizeModelTable fInternationalizeModelTable;

    private Button overwriteOption;
    private Button individualFragments;

    private class ContentProvider extends DefaultContentProvider implements IStructuredContentProvider {
        /**
         * @return the list of available non-selected plug-ins
         */
        public Object[] getElements(Object parent) {
            return fInternationalizeModelTable.getModels();
        }
    }

    private class SelectedContentProvider extends DefaultContentProvider implements IStructuredContentProvider {
        /**
         * @return the list of selected plug-ins
         */
        public Object[] getElements(Object parent) {
            return fInternationalizeModelTable.getPreSelected();
        }
    }

    public InternationalizeWizardPluginPage(InternationalizeModelTable modelTable, String pageName) {

        super(pageName);
        setTitle(MDEUIMessages.InternationalizeWizard_PluginPage_pageTitle);
        setDescription(MDEUIMessages.InternationalizeWizard_PluginPage_pageDescription);

        MDEPlugin.getDefault().getLabelProvider().connect(this);
        MDECore.getDefault().getModelManager().getExternalModelManager().addModelProviderListener(this);

        fInternationalizeModelTable = modelTable;

        IWizardContainer container = getContainer();
        if (container != null)
            container.updateButtons();
    }

    /**
     * Adds a filter to the list of available plug-ins
     */
    private void addFilter() {
        fFilter = new AvailableFilter(fSelected, MDEPlugin.getDefault().getLabelProvider());
        fAvailableViewer.addFilter(fFilter);
        fFilterJob = new WorkbenchJob("FilterJob") { //$NON-NLS-1$
            public IStatus runInUIThread(IProgressMonitor monitor) {
                handleFilter();
                return Status.OK_STATUS;
            }
        };
        fFilterJob.setSystem(true);
    }

    /**
     * Handles changes to the list based on changes to the text field.
     */
    private void handleFilter() {
        boolean changed = false;
        String newFilter;
        if (fFilterText == null || (newFilter = fFilterText.getText().trim()).length() == 0)
            newFilter = AvailableFilter.WILDCARD;
        changed = fFilter.setPattern(newFilter);
        if (changed) {
            fAvailableViewer.getTable().setRedraw(false);
            fAvailableViewer.refresh();
            fAvailableViewer.getTable().setRedraw(true);
            updateButtonEnablement(false, false);
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
     */
    public void createControl(Composite parent) {
        Composite container = new Composite(parent, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.numColumns = 3;
        layout.makeColumnsEqualWidth = false;
        layout.horizontalSpacing = 5;
        layout.verticalSpacing = 20;
        container.setLayout(layout);

        createScrollArea(container);
        createAvailableList(container).setLayoutData(new GridData(GridData.FILL_BOTH));
        createButtonArea(container);
        createInternationalizeList(container).setLayoutData(new GridData(GridData.FILL_BOTH));
        updateCount();

        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        data.horizontalSpan = 3;
        Composite comp = new Composite(container, SWT.NONE);
        comp.setLayoutData(data);
        GridLayout fl = new GridLayout(2, false);
        comp.setLayout(fl);

        IDialogSettings settings = getDialogSettings();
        String template = settings.get(TEMPLATE);

        Label label = new Label(comp, SWT.NONE);
        label.setText(MDEUIMessages.InternationalizeWizard_PluginPage_templateLabel);
        fTemplateText = new Text(comp, SWT.BORDER);
        fTemplateText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        fTemplateText.setText(template != null ? template : NLSFragmentGenerator.PLUGIN_NAME_MACRO + ".nl1"); //$NON-NLS-1$
        fTemplateText.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                pageChanged();
            }
        });

        GridData gd = new GridData(GridData.FILL_HORIZONTAL);
        gd.horizontalSpan = 2;

        overwriteOption = new Button(comp, SWT.CHECK);
        overwriteOption.setText(MDEUIMessages.InternationalizeWizard_PluginPage_overwriteWithoutAsking);
        overwriteOption.setSelection(settings.getBoolean(OVERWRITE));
        overwriteOption.setLayoutData(gd);

        individualFragments = new Button(comp, SWT.CHECK);
        individualFragments.setText(MDEUIMessages.InternationalizeWizard_PluginPage_individualFragments);
        individualFragments.setSelection(settings.getBoolean(CREATE_INDIVIDUAL_FRAGMENTS));
        individualFragments.setLayoutData(gd);

        addViewerListeners();
        addFilter();

        initialize();
        setControl(container);
        Dialog.applyDialogFont(container);
    }

    /**
     * @param parent
     * @return the container holding the available plug-ins list
     */
    private Composite createAvailableList(Composite parent) {
        Composite container = createViewerContainer(parent,
                MDEUIMessages.InternationalizeWizard_PluginPage_availableList);
        fAvailableViewer = createTableViewer(container, new ContentProvider(),
                MDECore.getDefault().getModelManager());
        return container;
    }

    protected Composite createInternationalizeList(Composite parent) {
        Composite container = createViewerContainer(parent,
                MDEUIMessages.InternationalizeWizard_PluginPage_internationalizeList);
        fSelectedViewer = createTableViewer(container, new SelectedContentProvider(),
                MDECore.getDefault().getModelManager().getExternalModelManager());
        return container;
    }

    private Composite createViewerContainer(Composite parent, String message) {
        Composite container = new Composite(parent, SWT.NONE);
        GridLayout layout = new GridLayout();
        layout.marginWidth = 0;
        layout.marginHeight = 0;
        container.setLayout(layout);
        container.setLayoutData(new GridData(GridData.FILL_BOTH));

        Label label = new Label(container, SWT.NONE);
        label.setText(message);
        return container;
    }

    private static TableViewer createTableViewer(Composite container, IContentProvider provider, Object manager) {
        Table table = new Table(container, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);
        GridData gd = new GridData(GridData.FILL_BOTH);
        gd.heightHint = 200;
        gd.widthHint = 225;
        table.setLayoutData(gd);

        TableViewer viewer = new TableViewer(table);
        viewer.setLabelProvider(MDEPlugin.getDefault().getLabelProvider());
        viewer.setContentProvider(provider);
        viewer.setInput(manager);
        viewer.setComparator(ListUtil.PLUGIN_COMPARATOR);
        return viewer;
    }

    protected boolean isRefreshNeeded() {
        if (fRefreshNeeded) {
            fRefreshNeeded = false;
            return true;
        }

        return false;
    }

    private IMonitorModelBase findModel(String id) {
        for (int i = 0; i < fModels.length; i++) {
            String modelId = fModels[i].getMonitorBase().getId();
            if (modelId != null && modelId.equals(id))
                return fModels[i];
        }
        return null;
    }

    private IFragmentModel[] findFragments(IMonitor plugin) {
        ArrayList result = new ArrayList();
        for (int i = 0; i < fModels.length; i++) {
            if (fModels[i] instanceof IFragmentModel) {
                IFragment fragment = ((IFragmentModel) fModels[i]).getFragment();
                if (plugin.getId().equalsIgnoreCase(fragment.getPluginId())) {
                    result.add(fModels[i]);
                }
            }
        }
        return (IFragmentModel[]) result.toArray(new IFragmentModel[result.size()]);
    }

    protected void addPluginAndDependencies(IMonitorModelBase model, ArrayList selected, boolean addFragments) {

        boolean containsVariable = false;
        if (!selected.contains(model)) {
            selected.add(model);
            boolean hasextensibleAPI = ClasspathUtilCore.hasExtensibleAPI(model);
            if (!addFragments && !hasextensibleAPI && model instanceof IMonitorModel) {
                IMonitorLibrary[] libraries = model.getMonitorBase().getLibraries();
                for (int i = 0; i < libraries.length; i++) {
                    if (ClasspathUtilCore.containsVariables(libraries[i].getName())) {
                        containsVariable = true;
                        break;
                    }
                }
            }
            addDependencies(model, selected, addFragments || containsVariable || hasextensibleAPI);
        }
    }

    protected void addDependencies(IMonitorModelBase model, ArrayList selected, boolean addFragments) {

        IMonitorImport[] required = model.getMonitorBase().getImports();
        if (required.length > 0) {
            for (int i = 0; i < required.length; i++) {
                IMonitorModelBase found = findModel(required[i].getId());
                if (found != null) {
                    addPluginAndDependencies(found, selected, addFragments);
                }
            }
        }

        if (addFragments) {
            if (model instanceof IMonitorModel) {
                IFragmentModel[] fragments = findFragments(((IMonitorModel) model).getMonitor());
                for (int i = 0; i < fragments.length; i++) {
                    addPluginAndDependencies(fragments[i], selected, addFragments);
                }
            } else {
                IFragment fragment = ((IFragmentModel) model).getFragment();
                IMonitorModelBase found = findModel(fragment.getPluginId());
                if (found != null) {
                    addPluginAndDependencies(found, selected, addFragments);
                }
            }
        }
    }

    public List getModelsToInternationalize() {
        TableItem[] items = fSelectedViewer.getTable().getItems();
        List result = new ArrayList();
        for (int i = 0; i < items.length; i++) {
            result.add(items[i].getData());
        }
        return result;
    }

    public void storeSettings() {
        IDialogSettings settings = getDialogSettings();
        settings.put(OVERWRITE, overwriteWithoutAsking());
        settings.put(TEMPLATE, getTemplate());
        settings.put(CREATE_INDIVIDUAL_FRAGMENTS, createIndividualFragments());
    }

    public boolean createIndividualFragments() {
        return individualFragments.getSelection();
    }

    /* (non-Javadoc)
     * @see org.eclipse.pde.core.IModelProviderListener#modelsChanged(org.eclipse.pde.core.IModelProviderEvent)
     */
    public void modelsChanged(IModelProviderEvent event) {
        fRefreshNeeded = true;
    }

    private void initialize() {
        updateButtonEnablement(true, true);
        setPageComplete(false);
    }

    private void addViewerListeners() {
        fAvailableViewer.addDoubleClickListener(new IDoubleClickListener() {
            public void doubleClick(DoubleClickEvent event) {
                handleAdd();
            }
        });

        fSelectedViewer.addDoubleClickListener(new IDoubleClickListener() {
            public void doubleClick(DoubleClickEvent event) {
                handleRemove();
            }
        });

        fAvailableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
            public void selectionChanged(SelectionChangedEvent event) {
                if (!fBlockSelectionListeners)
                    updateSelectionBasedEnablement(event.getSelection(), true);
            }
        });

        fSelectedViewer.addSelectionChangedListener(new ISelectionChangedListener() {
            public void selectionChanged(SelectionChangedEvent event) {
                if (!fBlockSelectionListeners)
                    updateSelectionBasedEnablement(event.getSelection(), false);
            }
        });

        fFilterText.addModifyListener(new ModifyListener() {
            public void modifyText(ModifyEvent e) {
                fFilterJob.cancel();
                fFilterJob.schedule(200);
            }
        });

    }

    private Composite createButtonArea(Composite parent) {
        ScrolledComposite comp = new ScrolledComposite(parent, SWT.V_SCROLL | SWT.H_SCROLL);
        GridLayout layout = new GridLayout();
        layout.marginWidth = layout.marginHeight = 0;
        comp.setLayoutData(new GridData(GridData.FILL_VERTICAL));
        Composite container = new Composite(comp, SWT.NONE);
        layout = new GridLayout();
        layout.marginWidth = 0;
        layout.marginTop = 50;
        container.setLayout(layout);
        GridData gd = new GridData(GridData.FILL_VERTICAL);
        gd.verticalIndent = 15;
        container.setLayoutData(gd);

        fAddButton = new Button(container, SWT.PUSH);
        fAddButton.setText(MDEUIMessages.ImportWizard_DetailedPage_add);
        fAddButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        fAddButton.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleAdd();
            }
        });
        SWTUtil.setButtonDimensionHint(fAddButton);

        fAddAllButton = new Button(container, SWT.PUSH);
        fAddAllButton.setText(MDEUIMessages.ImportWizard_DetailedPage_addAll);
        fAddAllButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        fAddAllButton.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleAddAll();
            }
        });
        SWTUtil.setButtonDimensionHint(fAddAllButton);

        fRemoveButton = new Button(container, SWT.PUSH);
        fRemoveButton.setText(MDEUIMessages.ImportWizard_DetailedPage_remove);
        fRemoveButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        fRemoveButton.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleRemove();
            }
        });
        SWTUtil.setButtonDimensionHint(fRemoveButton);

        fRemoveAllButton = new Button(container, SWT.PUSH);
        fRemoveAllButton.setText(MDEUIMessages.ImportWizard_DetailedPage_removeAll);
        fRemoveAllButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        fRemoveAllButton.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleRemoveAll();
            }
        });
        SWTUtil.setButtonDimensionHint(fRemoveAllButton);

        fCountLabel = new Label(container, SWT.NONE);
        fCountLabel.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_CENTER));
        comp.setContent(container);
        comp.setMinHeight(250);
        comp.setExpandHorizontal(true);
        comp.setExpandVertical(true);
        return container;
    }

    private Composite createScrollArea(Composite parent) {
        Group container = createFilterContainer(parent, MDEUIMessages.InternationalizeWizard_PluginPage_filter,
                MDEUIMessages.ImportWizard_DetailedPage_search);
        fFilterText = createFilterText(container, ""); //$NON-NLS-1$
        return container;
    }

    protected void refreshPage() {
        fSelectedViewer.getTable().removeAll();
        fSelected.clear();
        fAvailableViewer.refresh();
        pageChanged();
    }

    protected void pageChanged() {
        pageChanged(false, false);
    }

    protected void pageChanged(boolean doAddEnablement, boolean doRemoveEnablement) {
        if (fTemplateText.getText().length() == 0) {
            setErrorMessage(MDEUIMessages.InternationalizeWizard_PluginPage_templateError);
        } else if (fSelectedViewer.getTable().getItemCount() == 0) {
            setErrorMessage(MDEUIMessages.InternationalizeWizard_PluginPage_selectionError);
        } else {
            setErrorMessage(null);
        }

        updateCount();
        updateButtonEnablement(doAddEnablement, doRemoveEnablement);
        setPageComplete(fSelectedViewer.getTable().getItemCount() > 0);
    }

    private void updateCount() {
        fCountLabel.setText(NLS.bind(MDEUIMessages.ImportWizard_DetailedPage_count,
                (new String[] { new Integer(fSelectedViewer.getTable().getItemCount()).toString(), new Integer(
                        fAvailableViewer.getTable().getItemCount() + fSelectedViewer.getTable().getItemCount())
                                .toString() })));
        fCountLabel.getParent().layout();
    }

    private void updateButtonEnablement(boolean doAddEnablement, boolean doRemoveEnablement) {
        int availableCount = fAvailableViewer.getTable().getItemCount();
        int importCount = fSelectedViewer.getTable().getItemCount();

        if (doAddEnablement)
            updateSelectionBasedEnablement(fAvailableViewer.getSelection(), true);
        if (doRemoveEnablement)
            updateSelectionBasedEnablement(fSelectedViewer.getSelection(), false);

        fAddAllButton.setEnabled(availableCount > 0);
        fRemoveAllButton.setEnabled(importCount > 0);
    }

    private void updateSelectionBasedEnablement(ISelection theSelection, boolean available) {
        if (available)
            fAddButton.setEnabled(!theSelection.isEmpty());
        else
            fRemoveButton.setEnabled(!theSelection.isEmpty());
    }

    private void handleAdd() {
        IStructuredSelection ssel = (IStructuredSelection) fAvailableViewer.getSelection();
        if (ssel.size() > 0) {
            Table table = fAvailableViewer.getTable();
            int index = table.getSelectionIndices()[0];
            Object[] selection = ssel.toArray();
            setBlockSelectionListeners(true);
            setRedraw(false);
            for (int i = 0; i < selection.length; i++) {
                doAdd(selection[i]);
            }
            setRedraw(true);
            setBlockSelectionListeners(false);
            table.setSelection(index < table.getItemCount() ? index : table.getItemCount() - 1);
            pageChanged(true, false);
        }
    }

    private void handleAddAll() {
        TableItem[] items = fAvailableViewer.getTable().getItems();

        ArrayList data = new ArrayList();
        for (int i = 0; i < items.length; i++) {
            data.add(items[i].getData());
        }
        if (data.size() > 0) {
            Object[] datas = data.toArray();
            setBlockSelectionListeners(true);
            setRedraw(false);
            for (int i = 0; i < datas.length; i++) {
                doAdd(datas[i]);
            }
            setRedraw(true);
            setBlockSelectionListeners(false);
            pageChanged(true, false);
        }
    }

    private void handleRemove() {
        IStructuredSelection ssel = (IStructuredSelection) fSelectedViewer.getSelection();
        if (ssel.size() > 0) {
            Table table = fSelectedViewer.getTable();
            int index = table.getSelectionIndices()[0];
            Object[] selection = ssel.toArray();
            setBlockSelectionListeners(true);
            setRedraw(false);
            for (int i = 0; i < selection.length; i++) {
                doRemove(selection[i]);
            }
            setRedraw(true);
            setBlockSelectionListeners(false);
            table.setSelection(index < table.getItemCount() ? index : table.getItemCount() - 1);
            pageChanged(false, true);
        }
    }

    private void doAdd(Object o) {
        fInternationalizeModelTable.removeModel(o);
        fSelectedViewer.add(o);
        fAvailableViewer.remove(o);
        fSelected.put(o, null);
    }

    private void doRemove(Object o) {
        fInternationalizeModelTable.addModel(o);
        fSelected.remove(o);
        fSelectedViewer.remove(o);
        fAvailableViewer.add(o);
    }

    // used to prevent flicker during operations that move items between lists
    private void setRedraw(boolean redraw) {
        fAvailableViewer.getTable().setRedraw(redraw);
        fSelectedViewer.getTable().setRedraw(redraw);
    }

    private void handleRemoveAll() {
        TableItem[] items = fSelectedViewer.getTable().getItems();

        ArrayList data = new ArrayList();
        for (int i = 0; i < items.length; i++) {
            data.add(items[i].getData());
        }
        if (data.size() > 0) {
            Object[] datas = data.toArray();
            setBlockSelectionListeners(true);
            setRedraw(false);
            for (int i = 0; i < datas.length; i++) {
                doRemove(datas[i]);
            }
            setRedraw(true);
            setBlockSelectionListeners(false);
            pageChanged(false, true);
        }
    }

    public void dispose() {
        MDEPlugin.getDefault().getLabelProvider().disconnect(this);
        MDECore.getDefault().getModelManager().getExternalModelManager().removeModelProviderListener(this);
    }

    private void setBlockSelectionListeners(boolean blockSelectionListeners) {
        fBlockSelectionListeners = blockSelectionListeners;
    }

    public boolean isCurrentPage() {
        return super.isCurrentPage();
    }

    public boolean canFlipToNextPage() {
        if (fSelectedViewer.getTable().getItems().length > 0 && getTemplate().length() > 0) {
            return true;
        }
        return false;
    }

    public String getTemplate() {
        return fTemplateText.getText();
    }

    public boolean overwriteWithoutAsking() {
        return overwriteOption.getSelection();
    }
}