Attachment #93695 for bug #201998

Lines 12-17 Link Here

(-)src/org/eclipse/pde/internal/ui/nls/GetNonExternalizedStringsOperation.java (-7 / +29 lines)
12		12
13	import java.lang.reflect.InvocationTargetException;	13	import java.lang.reflect.InvocationTargetException;
14	import java.util.ArrayList;	14	import java.util.ArrayList;
		15	import java.util.Iterator;
15	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.resources.IFile;
16	import org.eclipse.core.resources.IProject;	17	import org.eclipse.core.resources.IProject;
17	import org.eclipse.core.runtime.*;	18	import org.eclipse.core.runtime.*;
Lines 37-44 Link Here
37	private ModelChangeTable fModelChangeTable;	38	private ModelChangeTable fModelChangeTable;
38	private boolean fCanceled;	39	private boolean fCanceled;
39		40
40	public GetNonExternalizedStringsOperation(ISelection selection) {	41	//Azure: To indicate that only selected plug-ins under <code>fSelection</code> are to be externalized.
		42	private boolean fExternalizeSelectedPluginsOnly;
		43
		44	public GetNonExternalizedStringsOperation(ISelection selection, boolean externalizeSelectedPluginsOnly) {
41	fSelection = selection;	45	fSelection = selection;
		46	fExternalizeSelectedPluginsOnly = externalizeSelectedPluginsOnly;
42	}	47	}
43		48
44	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {	49	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
Lines 56-67 Link Here
56		61
57	fModelChangeTable = new ModelChangeTable();	62	fModelChangeTable = new ModelChangeTable();
58		63
59	IPluginModelBase[] pluginModels = PluginRegistry.getWorkspaceModels();	64	/*
60	monitor.beginTask(PDEUIMessages.GetNonExternalizedStringsOperation_taskMessage, pluginModels.length);	65	* Azure: This will add only the preselected plug-ins to the ModelChangeTable
61	for (int i = 0; i < pluginModels.length && !fCanceled; i++) {	66	* instead of adding the list of all plug-ins in the workspace. This is useful
62	IProject project = pluginModels[i].getUnderlyingResource().getProject();	67	* when the Internationalize action is run on a set of non-externalized plug-ins
63	if (!WorkspaceModelManager.isBinaryProject(project))	68	* where there is no need to display all non-externalized plug-ins in the
64	getUnExternalizedStrings(project, new SubProgressMonitor(monitor, 1));	69	* workspace, but only those selected.
		70	*/
		71	if (fExternalizeSelectedPluginsOnly) {
		72	monitor.beginTask(PDEUIMessages.GetNonExternalizedStringsOperation_taskMessage, fSelectedModels.size());
		73	Iterator iterator = fSelectedModels.iterator();
		74	while (iterator.hasNext() && !fCanceled) {
		75	IProject project = (IProject) iterator.next();
		76	if (!WorkspaceModelManager.isBinaryProject(project))
		77	getUnExternalizedStrings(project, new SubProgressMonitor(monitor, 1));
		78	}
		79	} else {
		80	IPluginModelBase[] pluginModels = PluginRegistry.getWorkspaceModels();
		81	monitor.beginTask(PDEUIMessages.GetNonExternalizedStringsOperation_taskMessage, pluginModels.length);
		82	for (int i = 0; i < pluginModels.length && !fCanceled; i++) {
		83	IProject project = pluginModels[i].getUnderlyingResource().getProject();
		84	if (!WorkspaceModelManager.isBinaryProject(project))
		85	getUnExternalizedStrings(project, new SubProgressMonitor(monitor, 1));
		86	}
65	}	87	}
66	}	88	}
67	}	89	}

Lines 23-34 Link Here

(-)src/org/eclipse/pde/internal/ui/nls/GetNonExternalizedStringsAction.java (-3 / +52 lines)
23	public class GetNonExternalizedStringsAction implements IWorkbenchWindowActionDelegate {	23	public class GetNonExternalizedStringsAction implements IWorkbenchWindowActionDelegate {
24		24
25	private ISelection fSelection;	25	private ISelection fSelection;
		26	//Azure: To indicate that only selected plug-ins are to be externalized. False by default.
		27	private boolean fExternalizeSelectedPluginsOnly = false;
		28
		29	//Azure: To indicate that the post-externalization message dialog should not be displayed.
		30	private boolean fSkipMessageDialog = false;
26		31
27	public GetNonExternalizedStringsAction() {	32	public GetNonExternalizedStringsAction() {
28	}	33	}
29		34
30	public void run(IAction action) {	35	public void run(IAction action) {
31	GetNonExternalizedStringsOperation runnable = new GetNonExternalizedStringsOperation(fSelection);	36	/*
		37	* Azure: Pass <code>fExternalizeSelectedPluginsOnly</code> to the operation to indicate
		38	* that only the plug-ins passed in the selection are to be externalized and such that
		39	* only those are displayed on the change table in the ExternalizeStringsWizard.
		40	*/
		41	GetNonExternalizedStringsOperation runnable = new GetNonExternalizedStringsOperation(fSelection, fExternalizeSelectedPluginsOnly);
32	try {	42	try {
33	PlatformUI.getWorkbench().getProgressService().busyCursorWhile(runnable);	43	PlatformUI.getWorkbench().getProgressService().busyCursorWhile(runnable);
34	} catch (InvocationTargetException e) {	44	} catch (InvocationTargetException e) {
Lines 47-54 Link Here
47	op.run(PDEPlugin.getActiveWorkbenchShell(), ""); //$NON-NLS-1$	57	op.run(PDEPlugin.getActiveWorkbenchShell(), ""); //$NON-NLS-1$
48	} catch (final InterruptedException irex) {	58	} catch (final InterruptedException irex) {
49	}	59	}
50	} else	60	} else {
51	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), PDEUIMessages.GetNonExternalizedStringsAction_allExternalizedTitle, PDEUIMessages.GetNonExternalizedStringsAction_allExternalizedMessage);	61	/*
		62	* Azure: When the InternationalizeAction invokes the ExternalizeStringsAction,
		63	* <code>fSkipMessageDialog</code> is set to true in order for no intermediate
		64	* message to appear if all selected plug-ins were already externalized.
		65	*/
		66	if (!fSkipMessageDialog)
		67	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), PDEUIMessages.GetNonExternalizedStringsAction_allExternalizedTitle, PDEUIMessages.GetNonExternalizedStringsAction_allExternalizedMessage);
		68	}
52	}	69	}
53	}	70	}
54		71
Lines 61-64 Link Here
61		78
62	public void init(IWorkbenchWindow window) {	79	public void init(IWorkbenchWindow window) {
63	}	80	}
		81
		82	/**
		83	* TODO: Azure Documentation
		84	* @param externalizeSelectedPluginsOnly
		85	*/
		86	public void setExternalizeSelectedPluginsOnly(boolean externalizeSelectedPluginsOnly) {
		87	fExternalizeSelectedPluginsOnly = externalizeSelectedPluginsOnly;
		88	}
		89
		90	/**
		91	* TODO: Azure Documentation
		92	* @return
		93	*/
		94	public boolean isExternalizeSelectedPluginsOnly() {
		95	return fExternalizeSelectedPluginsOnly;
		96	}
		97
		98	/**
		99	* TODO: Azure Documentation
		100	* @param skipMessageDialog
		101	*/
		102	public void setSkipMessageDialog(boolean skipMessageDialog) {
		103	this.fSkipMessageDialog = skipMessageDialog;
		104	}
		105
		106	/**
		107	* TODO: Azure Documentation
		108	* @return
		109	*/
		110	public boolean isSkipMessageDialog() {
		111	return fSkipMessageDialog;
		112	}
64	}	113	}




package org.eclipse.pde.internal.ui.nls;

import java.util.Locale;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.swt.graphics.Image;

public class LocaleLabelProvider implements ILabelProvider {

	public Image getImage(Object element) {
		return null;
	}

	public String getText(Object element) {
		Locale locale = (Locale) element;
		String country = " (" + locale.getDisplayCountry() + ")";
		return locale.getDisplayLanguage() + (" ()".equals(country) ? "" : country);
	}

	public void addListener(ILabelProviderListener listener) {
		// TODO Auto-generated method stub

	}

	public void dispose() {
		// TODO Auto-generated method stub
	}

	public boolean isLabelProperty(Object element, String property) {
		// TODO Auto-generated method stub
		return false;
	}

	public void removeListener(ILabelProviderListener listener) {
		// TODO Auto-generated method stub

	}
}




package org.eclipse.pde.internal.ui.nls;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;

public abstract class InternationalizationWizardPage extends WizardPage {

	public InternationalizationWizardPage(String pageName) {
		super(pageName);
	}

	public InternationalizationWizardPage(String pageName, String title, ImageDescriptor titleImage) {
		super(pageName, title, titleImage);
	}

	protected Group createFilterContainer(Composite parent, String title, String label) {
		Group container = new Group(parent, SWT.NONE);
		GridLayout layout = new GridLayout(2, false);
		layout.marginWidth = layout.marginHeight = 6;
		container.setLayout(layout);

		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 3;
		container.setLayoutData(gd);
		container.setText(title);

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

	protected Text createFilterText(Composite parent, String initial) {
		Text text = new Text(parent, SWT.BORDER);
		text.setText(initial);
		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		text.setLayoutData(gd);
		return text;
	}

}




package org.eclipse.pde.internal.ui.nls;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Shell;

/**
 * A helper class to open an InternationalizeWizard dialog.
 * 
 * @author Team Azure
 */
public class InternationalizeWizardOpenOperation {

	private InternationalizeWizard fWizard;

	public InternationalizeWizardOpenOperation(InternationalizeWizard wizard) {
		Assert.isNotNull(wizard);
		fWizard = wizard;
	}

	public int run(final Shell parent, final String dialogTitle) throws InterruptedException {
		Assert.isNotNull(dialogTitle);
		final IJobManager manager = Job.getJobManager();
		final int[] result = new int[1];
		final InterruptedException[] canceled = new InterruptedException[1];

		Runnable r = new Runnable() {
			public void run() {
				try {
					manager.beginRule(ResourcesPlugin.getWorkspace().getRoot(), null);

					Dialog dialog = new WizardDialog(parent, fWizard);
					dialog.create();

					IWizardContainer wizardContainer = (IWizardContainer) dialog;
					if (wizardContainer.getCurrentPage() == null) {
						//Close the dialog if there are no pages
						result[0] = Window.CANCEL;
					} else {
						//Open the wizard dialog
						result[0] = dialog.open();
					}

				} catch (OperationCanceledException e) {
					canceled[0] = new InterruptedException(e.getMessage());
				} finally {
					manager.endRule(ResourcesPlugin.getWorkspace().getRoot());
				}
			}
		};
		BusyIndicator.showWhile(parent.getDisplay(), r);
		if (canceled[0] != null)
			throw canceled[0];
		return result[0];
	}
}




/*******************************************************************************
 * 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 org.eclipse.pde.internal.ui.nls;

import java.lang.reflect.InvocationTargetException;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.ui.*;

/**
 * This action class is responsible for creating and initializing the
 * InternationalizeWizard.
 * 
 * @author Team Azure
 *
 */
public class InternationalizeAction implements IWorkbenchWindowActionDelegate {

	private IStructuredSelection fSelection;

	public InternationalizeAction() {
	}

	public void run(IAction action) {
		//Create an InternationalizeOperation on the workbench selection.
		InternationalizeOperation runnable = new InternationalizeOperation(fSelection);
		try {
			PlatformUI.getWorkbench().getProgressService().busyCursorWhile(runnable);
		} catch (InvocationTargetException e) {
		} catch (InterruptedException e) {
		} finally {
			if (runnable.wasCanceled()) {
				return;
			}

			/*	Get the plugin model table containing the list of workspace and 
			 * 	external plug-ins
			 */
			InternationalizeModelTable pluginTable = runnable.getPluginTable();

			if (!pluginTable.isEmpty()) {

				InternationalizeWizard wizard = new InternationalizeWizard(action, pluginTable);
				wizard.init(PlatformUI.getWorkbench(), fSelection);

				//Create an operation to start and run the wizard
				InternationalizeWizardOpenOperation op = new InternationalizeWizardOpenOperation(wizard);
				try {
					op.run(PDEPlugin.getActiveWorkbenchShell(), ""); //$NON-NLS-1$
				} catch (final InterruptedException irex) {
				}
			} else {
				MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), PDEUIMessages.InternationalizeAction_internationalizeTitle, PDEUIMessages.InternationalizeAction_internationalizeMessage);
			}
		}
	}

	public void selectionChanged(IAction action, ISelection selection) {
		fSelection = (IStructuredSelection) selection;
	}

	public void dispose() {
	}

	public void init(IWorkbenchWindow window) {
	}
}




/**
 * 
 */
package org.eclipse.pde.internal.ui.nls;

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.layout.GridLayoutFactory;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.IModelProviderEvent;
import org.eclipse.pde.core.IModelProviderListener;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.elements.DefaultContentProvider;
import org.eclipse.pde.internal.ui.util.SWTUtil;
import org.eclipse.pde.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.PlatformUI;
import org.eclipse.ui.progress.WorkbenchJob;

/**
 * @author Robbie
 *
 */
public class InternationalizeWizardLocalePage extends InternationalizationWizardPage implements IModelProviderListener {

	public static final String PAGE_NAME = "InternationalizeWizardLocalePage"; //$NON-NLS-1$

	protected Locale[] fModels = new Locale[0];
	private String fLocation;

	protected TableViewer fSelectedListViewer;
	private boolean fRefreshNeeded = true;

	private Label fCountLabel;
	private TableViewer fAvailableListViewer;

	// this job is used to delay the full filter refresh for 200 milliseconds in case the user is still typing
	private WorkbenchJob fFilterJob;
	private Text fFilterText;
	private AvailableFilter fFilter;

	// fSelected is used to track the selection in a HashMap so we can efficiently
	// filter selected items out of the available item list
	private HashMap fSelected;
	// 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;

	private InternationalizeModelTable fInternationalizeModelTable;

	private class ContentProvider extends DefaultContentProvider implements IStructuredContentProvider {
		public Object[] getElements(Object inputElement) {
			return ((InternationalizeModelTable) inputElement).getModels();
		}
	}

	public InternationalizeWizardLocalePage(InternationalizeModelTable modelTable, String pageName) {
		super(pageName);
		setTitle(PDEUIMessages.InternationalizeWizard_LocalePage_pageTitle);
		setDescription(PDEUIMessages.InternationalizeWizard_LocalePage_pageDescription);

		PDEPlugin.getDefault().getLabelProvider().connect(this);
		PDECore.getDefault().getModelManager().getExternalModelManager().addModelProviderListener(this);

		fInternationalizeModelTable = modelTable;
		fSelected = new HashMap();

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

	private void addFilter() {
		fFilter = new AvailableFilter(fSelected, new LocaleLabelProvider());
		fAvailableListViewer.addFilter(fFilter);
		fFilterJob = new WorkbenchJob("FilterJob") { //$NON-NLS-1$
			public IStatus runInUIThread(IProgressMonitor monitor) {
				handleFilter();
				return Status.OK_STATUS;
			}
		};
		fFilterJob.setSystem(true);
	}

	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) {
			fAvailableListViewer.getTable().setRedraw(false);
			fAvailableListViewer.refresh();
			fAvailableListViewer.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);
		createLocaleList(container).setLayoutData(new GridData(GridData.FILL_BOTH));
		updateCount();

		// create container for buttons
		Composite buttonContainer = new Composite(container, SWT.NONE);
		buttonContainer.setLayout(GridLayoutFactory.fillDefaults().create());

		addViewerListeners();
		addFilter();

		initialize();
		setControl(container);
		Dialog.applyDialogFont(container);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(container, IHelpContextIds.PLUGIN_IMPORT_SECOND_PAGE);
	}

	protected Composite createLocaleList(Composite parent) {
		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(PDEUIMessages.InternationalizeWizard_LocalePage_internationalizeList);

		Table table = new Table(container, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);
		GridData gd = new GridData(GridData.FILL_BOTH);
		gd.widthHint = 225;
		table.setLayoutData(gd);

		fSelectedListViewer = new TableViewer(table);
		fSelectedListViewer.setLabelProvider(new LocaleLabelProvider());
		fSelectedListViewer.setContentProvider(new ContentProvider());
		fSelectedListViewer.setComparator(ListUtil.NAME_COMPARATOR);
		return container;
	}

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

	protected void addLocale(Locale model, ArrayList selected) {
		if (!selected.contains(model)) {
			selected.add(model);
		}
	}

	public List getLocalesForInternationalization() {
		TableItem[] items = fSelectedListViewer.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();
	}

	/* (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() {
		fAvailableListViewer.addDoubleClickListener(new IDoubleClickListener() {
			public void doubleClick(DoubleClickEvent event) {
				handleAdd();
			}
		});

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

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

		fSelectedListViewer.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 createAvailableList(Composite parent) {
		Composite container = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.marginWidth = 0;
		layout.marginHeight = 0;
		container.setLayout(layout);
		container.setLayoutData(new GridData());

		Label label = new Label(container, SWT.NONE);
		label.setText(PDEUIMessages.InternationalizeWizard_LocalePage_availableList);

		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);

		fAvailableListViewer = new TableViewer(table);
		fAvailableListViewer.setLabelProvider(new LocaleLabelProvider());
		fAvailableListViewer.setContentProvider(new ContentProvider());
		fAvailableListViewer.setInput(fInternationalizeModelTable);
		fAvailableListViewer.setComparator(ListUtil.NAME_COMPARATOR);

		return container;
	}

	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(PDEUIMessages.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(PDEUIMessages.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(PDEUIMessages.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(PDEUIMessages.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, PDEUIMessages.InternationalizeWizard_LocalePage_filter, PDEUIMessages.ImportWizard_DetailedPage_search);
		fFilterText = createFilterText(container, ""); //$NON-NLS-1$
		return container;
	}

	protected void refreshPage() {
		fSelectedListViewer.getTable().removeAll();
		fSelected = new HashMap();
		fAvailableListViewer.refresh();
		pageChanged();
	}

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

	protected void pageChanged(boolean doAddEnablement, boolean doRemoveEnablement) {
		if (fSelectedListViewer.getTable().getItemCount() == 0) {
			setErrorMessage(PDEUIMessages.InternationalizeWizard_LocalePage_selectionError);
		} else {
			setErrorMessage(null);
		}

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

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

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

		if (doAddEnablement)
			updateSelectionBasedEnablement(fAvailableListViewer.getSelection(), true);
		if (doRemoveEnablement)
			updateSelectionBasedEnablement(fSelectedListViewer.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) fAvailableListViewer.getSelection();
		if (ssel.size() > 0) {
			Table table = fAvailableListViewer.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 = fAvailableListViewer.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) fSelectedListViewer.getSelection();
		if (ssel.size() > 0) {
			Table table = fSelectedListViewer.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);
		fSelectedListViewer.add(o);
		fAvailableListViewer.remove(o);
		fSelected.put(o, null);
	}

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

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

	private void handleRemoveAll() {
		TableItem[] items = fSelectedListViewer.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() {
		PDEPlugin.getDefault().getLabelProvider().disconnect(this);
		PDECore.getDefault().getModelManager().getExternalModelManager().removeModelProviderListener(this);
	}

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

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

	public boolean canFlipToNextPage() {
		return false;
	}
}




package org.eclipse.pde.internal.ui.nls;

import java.util.*;
import org.eclipse.core.resources.IProject;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.internal.core.plugin.ExternalPluginModel;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.ui.IImportWizard;
import org.eclipse.ui.IWorkbench;

/**
 * An InternationalizeWizard is responsible for internationalizing a list of
 * specified plug-ins (workspace and external) to a set of specified locales.
 * This involves creating an NLS fragment project for every plug-in, which would
 * contain properties files for each specified locale. The first page of the wizard
 * allows the user to select the desired plug-ins and the second page the desired
 * locales. Also, the wizard ensures the plug-ins are externalized before proceeding
 * with internationlization.
 * 
 * @author Team Azure
 *
 */
public class InternationalizeWizard extends Wizard implements IImportWizard {
	private static final String STORE_SECTION = "InternationalizeWizard"; //$NON-NLS-1$

	private IAction action;
	private IStructuredSelection selection;

	//An intermediate selection passed to the ExternalizeStringsWizard
	private IStructuredSelection externalizeSelection;

	private InternationalizeWizardPluginPage page1;
	private InternationalizeWizardLocalePage page2;

	//Contains the list of plug-ins to be internationalized
	private InternationalizeModelTable fInternationalizePluginModelTable;

	//Contains the list of locales
	private InternationalizeModelTable fInternationalizeLocaleModelTable;

	public InternationalizeWizard(IAction action, InternationalizeModelTable pluginTable) {
		fInternationalizePluginModelTable = pluginTable;
		populateLocaleModelTable();
		IDialogSettings masterSettings = PDEPlugin.getDefault().getDialogSettings();
		setDialogSettings(getSettingsSection(masterSettings));
		setDefaultPageImageDescriptor(PDEPluginImages.DESC_EXTSTR_WIZ);
		setWindowTitle(PDEUIMessages.InternationalizeWizard_title);
		this.action = action;
	}

	/**
	 * Populates the local InternationalizeModelTable with the list of all
	 * available locales
	 */
	private void populateLocaleModelTable() {
		fInternationalizeLocaleModelTable = new InternationalizeModelTable();
		Locale[] availableLocales = Locale.getAvailableLocales();
		for (int i = 0; i < availableLocales.length; i++) {
			fInternationalizeLocaleModelTable.addModel(availableLocales[i]);
		}
	}

	/**
	 * Initialises selections
	 */
	public void init(IWorkbench workbench, IStructuredSelection selection) {
		this.selection = selection;
		externalizeSelection = this.selection;
	}

	/**
	 * Adds the plug-in and locale pages to the wizard
	 */
	public void addPages() {
		setNeedsProgressMonitor(true);
		page1 = new InternationalizeWizardPluginPage(fInternationalizePluginModelTable, "Plug-ins"); //$NON-NLS-1$
		addPage(page1);

		page2 = new InternationalizeWizardLocalePage(fInternationalizeLocaleModelTable, "Locales"); //$NON-NLS-1$
		addPage(page2);
	}

	/**
	 * 
	 * @param master
	 * @return the created setting for the InternationalizeWizard
	 */
	private IDialogSettings getSettingsSection(IDialogSettings master) {
		IDialogSettings setting = master.getSection(STORE_SECTION);
		if (setting == null) {
			setting = master.addNewSection(STORE_SECTION);
		}
		return setting;
	}

	/**
	 * 
	 * @return the list of plug-ins selected for internationalization
	 */
	private List getPluginModelsForInternationalization() {
		return page1.getModelsToInternationalize();
	}

	/**
	 * 
	 * @return the list of locales specified for internationalization
	 */
	private List getLocalesForInternationalization() {
		return page2.getLocalesForInternationalization();
	}

	public boolean performFinish() {
		page1.storeSettings();

		//Generate an NL fragment project for each of the selected plug-ins with the specified locales
		NLSFragmentGenerator fragmentGenerator = new NLSFragmentGenerator(page1.getTemplate(), getPluginModelsForInternationalization(), getLocalesForInternationalization(), this.getContainer(), page1.overwriteWithoutAsking());
		return fragmentGenerator.generate();
	}

	/**
	 * 
	 * @param currentPage
	 * @return the next wizard page
	 */
	public IWizardPage getNextPage(IWizardPage currentPage) {
		if (currentPage.equals(page1)) {
			ensurePluginsAreExternalized();
			return page2;
		}
		return null;
	}

	/**
	 * 
	 * @param currentPage
	 * @return the previous wizard page
	 */
	public IWizardPage getPreviousPage(IWizardPage currentPage) {
		if (currentPage.equals(page2)) {
			return page1;
		}
		return null;
	}

	public boolean canFinish() {
		return getPluginModelsForInternationalization().size() > 0 && getLocalesForInternationalization().size() > 0;
	}

	/**
	 * Checks whether or not the selected plug-ins are already externalized. This
	 * method invokes the ExternalizeStringsWizard on the selected plug-ins.
	 */
	public void ensurePluginsAreExternalized() {
		GetNonExternalizedStringsAction externalize = new GetNonExternalizedStringsAction();

		List projects = new ArrayList();
		List pluginModels = getPluginModelsForInternationalization();
		selection = new StructuredSelection(pluginModels); //Save the plug-ins selected for internationalization in a StructuredSelection

		for (Iterator it = pluginModels.iterator(); it.hasNext();) {
			IPluginModelBase pluginModel = (IPluginModelBase) it.next();
			//Externalize only workspace plug-ins since external plug-ins are already externalized
			if (!(pluginModel instanceof ExternalPluginModel)) {
				IProject project = pluginModel.getUnderlyingResource().getProject();
				projects.add(project);
			}
		}

		//Set the selection for the non-externalized plug-ins that 
		//should be passed to the ExternalizeStringsWizard
		externalizeSelection = new StructuredSelection(projects);

		externalize.selectionChanged(action, externalizeSelection);
		externalize.setExternalizeSelectedPluginsOnly(true);
		externalize.setSkipMessageDialog(true);
		externalize.run(action);
	}

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




package org.eclipse.pde.internal.ui.nls;

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.internal.core.TargetPlatformHelper;
import org.eclipse.pde.internal.core.plugin.ExternalPluginModelBase;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.pde.internal.ui.wizards.IProjectProvider;
import org.eclipse.pde.internal.ui.wizards.plugin.FragmentFieldData;
import org.eclipse.pde.internal.ui.wizards.plugin.NewProjectCreationOperation;

/**
 * 
 * Generates the fragment projects for the list of selected plug-ins.
 * Each fragment contains a series of properties files specific to the locales
 * the user selected. For example plugin_fr.properties for the french locale
 * selection. The generated locale-specific properties files contain the same
 * key-value pairs as the properties file of the initial plug-in.
 * 
 * @author Team Azure
 *
 */
public class NLSFragmentGenerator {

	public static final String PLUGIN_NAME_MACRO = "${plugin_name}"; //$NON-NLS-1$

	private static final double LATEST_ECLIPSE_VERSION = 3.4;

	private static final String ZERO = "0"; //$NON-NLS-1$
	private static final String PERIOD = "."; //$NON-NLS-1$
	private static final String MIN_MINOR = ZERO; //$NON-NLS-1$
	private static final String MAX_MINOR = "9"; //$NON-NLS-1$
	private static final String LEFT_SQUARE_BRACKET = "["; //$NON-NLS-1$
	private static final String RIGHT_PARENTHESIS = ")"; //$NON-NLS-1$
	private static final String DEFAULT_VERSION = "1.0.0"; //$NON-NLS-1$
	private static final String VERSION_FORMAT_WITH_QUALIFIER = "\\d+\\.\\d+\\.\\d+\\..+"; //$NON-NLS-1$
	private static final String PROPERTIES_FILE_EXTENSION = ".properties"; //$NON-NLS-1$
	private static final String LOCALE_PROPERTIES_FILE_PREFIX = "plugin_"; //$NON-NLS-1$
	private static final String JAR_SUFFIX = ".jar"; //$NON-NLS-1$
	private static final String PROPERTIES_FILE_NAME = "plugin.properties"; //$NON-NLS-1$
	private static final String PATH_SEPERATOR = "\\"; //$NON-NLS-1$

	private FragmentFieldData fFragmentData;
	private IProjectProvider fProjectProvider;
	private IWizardContainer container;
	private String template;

	private final List plugins;

	private final List locales;

	private final boolean overwriteWithoutAsking;

	public NLSFragmentGenerator(String template, List plugins, List locales, IWizardContainer container, boolean overwriteWithoutAsking) {
		this.plugins = plugins;
		this.locales = locales;
		this.container = container;
		this.template = template;
		this.overwriteWithoutAsking = overwriteWithoutAsking;
	}

	public boolean generate() {
		return internationalizePlugins(plugins, locales);
	}

	/**
	 * Creates an NL fragment project along with the locale specific properties
	 * files.
	 */
	private boolean internationalizePlugins(List plugins, List locales) {
		for (Iterator it = plugins.iterator(); it.hasNext();) {
			IPluginModelBase plugin = (IPluginModelBase) it.next();
			if (!createNLFragment(plugin))
				return false;

			IProject currentFragmentProject = ResourcesPlugin.getWorkspace().getRoot().getProject(pluginName(plugin));

			for (Iterator iter = locales.iterator(); iter.hasNext();) {
				Locale locale = (Locale) iter.next();
				createLocaleSpecificPropertiesFile(currentFragmentProject, plugin, locale);
			}
		}

		return true;
	}

	/**
	 * Creates a fragment project for the specified plug-in and populates
	 * the field data.
	 * @param plugin
	 */
	private boolean createNLFragment(IPluginModelBase plugin) {
		final String name = pluginName(plugin);
		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
		if (!overwriteWithoutAsking && project.exists()) {
			boolean overwrite = MessageDialog.openConfirm(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.InternationalizeWizard_NLSFragmentGenerator_overwriteTitle, NLS.bind(PDEUIMessages.InternationalizeWizard_NLSFragmentGenerator_overwriteMessage, name));
			if (!overwrite)
				return false;
		}

		if (project.exists()) {
			try {
				project.delete(true, new NullProgressMonitor());
			} catch (CoreException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}

		fFragmentData = new FragmentFieldData();

		populateFieldData(plugin);

		fProjectProvider = new IProjectProvider() {
			public String getProjectName() {
				return name;
			}

			public IProject getProject() {
				return ResourcesPlugin.getWorkspace().getRoot().getProject(getProjectName());
			}

			public IPath getLocationPath() {
				return new Path(Platform.getLocation().toOSString());
			}
		};

		try {
			container.run(false, true, new NewProjectCreationOperation(fFragmentData, fProjectProvider, null));
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return true;
	}

	private String pluginName(IPluginModelBase plugin) {
		return template.replace(PLUGIN_NAME_MACRO, plugin.getPluginBase().getId());
	}

	/**
	 * The fields are populated based on the plug-in attributes. Some fields
	 * are set to their default values.
	 */
	private void populateFieldData(IPluginModelBase plugin) {

		fFragmentData.setId(pluginName(plugin));
		fFragmentData.setVersion(DEFAULT_VERSION);
		fFragmentData.setMatch(0);

		fFragmentData.setPluginId(plugin.getPluginBase().getId());
		fFragmentData.setPluginVersion(incrementRelease(plugin.getPluginBase().getVersion()));
		fFragmentData.setName(pluginName(plugin) + " Fragment"); //$NON-NLS-1$
		fFragmentData.setProvider(""); //$NON-NLS-1$
		fFragmentData.setSimple(true);

		if (!(plugin instanceof ExternalPluginModelBase)) {
			fFragmentData.setSourceFolderName("src"); //$NON-NLS-1$
			fFragmentData.setOutputFolderName("bin"); //$NON-NLS-1$
		}

		fFragmentData.setLegacy(false);
		fFragmentData.setTargetVersion(Double.toString(ensureTargetVersionCompatibility(TargetPlatformHelper.getTargetVersion())));
		fFragmentData.setHasBundleStructure(true);
		fFragmentData.setOSGiFramework(null);
		fFragmentData.setWorkingSets(null);
	}

	/**
	 * Adjusts the plug-in's version to reflect the required
	 * fragment-host bundle-version range. For example, 
	 * fragment-host's bundle-version range would be: "[1.0.0, 1.1.0)" 
	 * if the host's version is 1.0.0
	 * @param oldVersion
	 * @return adjusted plug-in version
	 */
	private String incrementRelease(String oldVersion) {
		if (oldVersion.matches(VERSION_FORMAT_WITH_QUALIFIER)) {
			oldVersion = oldVersion.substring(0, oldVersion.lastIndexOf(PERIOD));
		}

		String newVersion = LEFT_SQUARE_BRACKET + oldVersion + ',';
		String oldMinor = oldVersion.substring(oldVersion.indexOf(PERIOD) + 1, oldVersion.lastIndexOf(PERIOD));

		if (oldMinor.compareTo(MAX_MINOR) == 0) {
			String major = Integer.toString(Integer.parseInt(oldVersion.substring(0, oldVersion.indexOf(PERIOD))) + 1);
			newVersion += major + PERIOD + MIN_MINOR + PERIOD + ZERO + RIGHT_PARENTHESIS;
		} else {
			String major = oldVersion.substring(0, oldVersion.indexOf(PERIOD));
			String newMinor = Integer.toString(Integer.parseInt(oldMinor) + 1);
			newVersion += major + PERIOD + newMinor + PERIOD + ZERO + RIGHT_PARENTHESIS;
		}

		return newVersion;
	}

	/**
	 * Creates a locale specific properties file within the fragment project 
	 * based on the content of the host plug-in's properties file.
	 * @param fragmentProject
	 * @param locale
	 */
	private void createLocaleSpecificPropertiesFile(IProject fragmentProject, IPluginModelBase plugin, Locale locale) {
		IFile localeProperties = fragmentProject.getFile(LOCALE_PROPERTIES_FILE_PREFIX + locale + PROPERTIES_FILE_EXTENSION);

		//Case 1: External plug-in
		if (plugin instanceof ExternalPluginModelBase) {
			String installLocation = plugin.getInstallLocation();
			//Case 1a: External plug-in is a jar file
			if (installLocation.endsWith(JAR_SUFFIX)) {
				try {
					ZipFile zf = new ZipFile(installLocation);
					ZipEntry zfe = zf.getEntry(PROPERTIES_FILE_NAME);
					InputStream is = zf.getInputStream(zfe);
					localeProperties.create(is, false, null);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			//Case 1b: External plug-in has a folder structure
			else {
				File propertiesFileLocation = new File(installLocation + PATH_SEPERATOR + PROPERTIES_FILE_NAME);
				try {
					FileInputStream is = new FileInputStream(propertiesFileLocation);
					localeProperties.create(is, false, null);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		//Case 2: Workspace plug-in
		else {
			IFile pluginProperties = plugin.getUnderlyingResource().getProject().getFile(PROPERTIES_FILE_NAME);

			if (!localeProperties.exists()) {
				try {
					pluginProperties.copy(localeProperties.getFullPath(), false, null);

				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * Ensures that the target version is compatible.
	 * @param targetVersion
	 * @return target version
	 */
	private double ensureTargetVersionCompatibility(double targetVersion) {
		if (targetVersion < 3.0) {
			return LATEST_ECLIPSE_VERSION;
		}
		return targetVersion;
	}
}




package org.eclipse.pde.internal.ui.nls;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.core.WorkspaceModelManager;
import org.eclipse.pde.internal.ui.PDEUIMessages;

/**
 * InternationalizeOperation is responsible for populating a plug-in model table
 * containing the list of plug-ins (workspace and external) prior to running the
 * wizard. An instance of this class must be created before creating an
 * InternationlizeWizard instance.
 * 
 * @author Team Azure
 *
 */
public class InternationalizeOperation implements IRunnableWithProgress {

	private ISelection fSelection;
	private ArrayList fSelectedModels;
	private InternationalizeModelTable fModelPluginTable;
	private boolean fCanceled;

	/**
	 * 
	 * @param selection represents the preselected plug-in projects in the workbench
	 */
	public InternationalizeOperation(ISelection selection) {
		fSelection = selection;
	}

	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {

		if (fSelection instanceof IStructuredSelection) {

			Object[] elems = ((IStructuredSelection) fSelection).toArray();

			fSelectedModels = new ArrayList(elems.length);
			for (int i = 0; i < elems.length; i++) {
				//If a file was selected, get its parent project
				if (elems[i] instanceof IFile)
					elems[i] = ((IFile) elems[i]).getProject();

				//Add the project to the preselected model list
				if (elems[i] instanceof IProject && WorkspaceModelManager.isPluginProject((IProject) elems[i]) && !WorkspaceModelManager.isBinaryProject((IProject) elems[i]))
					fSelectedModels.add(elems[i]);
			}
		}

		//Get all models (workspace and external) excluding fragment models
		IPluginModelBase[] pluginModels = PluginRegistry.getAllModels(false);
		monitor.beginTask(PDEUIMessages.GetNonExternalizedStringsOperation_taskMessage, pluginModels.length);

		//Populate list to an InternationalizeModelTable
		fModelPluginTable = new InternationalizeModelTable();
		for (int i = 0; i < pluginModels.length; i++) {
			fModelPluginTable.addToModelTable(pluginModels[i], pluginModels[i].getUnderlyingResource() != null ? selected(pluginModels[i].getUnderlyingResource().getProject()) : false);
		}
	}

	/**
	 * 
	 * @return whether or not the operation was cancelled
	 */
	public boolean wasCanceled() {
		return fCanceled;
	}

	/**
	 * 
	 * @param project
	 * @return whether or not the project was preselected
	 */
	public boolean selected(IProject project) {
		return fSelectedModels.contains(project);
	}

	/**
	 * 
	 * @return the InternationalizeModelTable containing the plug-ins
	 */
	public InternationalizeModelTable getPluginTable() {
		return fModelPluginTable;
	}
}




/**
 * 
 */
package org.eclipse.pde.internal.ui.nls;

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 org.eclipse.pde.core.IModelProviderEvent;
import org.eclipse.pde.core.IModelProviderListener;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.ClasspathUtilCore;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.ui.*;
import org.eclipse.pde.internal.ui.elements.DefaultContentProvider;
import org.eclipse.pde.internal.ui.util.SWTUtil;
import org.eclipse.pde.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.PlatformUI;
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.
 * 
 * @author Team Azure
 *
 */
public class InternationalizeWizardPluginPage extends InternationalizationWizardPage implements IModelProviderListener {

	public static final String PAGE_NAME = "InternationalizeWizardPluginPage"; //$NON-NLS-1$

	protected IPluginModelBase[] fModels = new IPluginModelBase[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 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(PDEUIMessages.InternationalizeWizard_PluginPage_pageTitle);
		setDescription(PDEUIMessages.InternationalizeWizard_PluginPage_pageDescription);

		PDEPlugin.getDefault().getLabelProvider().connect(this);
		PDECore.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, PDEPlugin.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();

		createTemplateField(container);
		overwriteOption = new Button(container, SWT.CHECK);
		overwriteOption.setText(PDEUIMessages.InternationalizeWizard_PluginPage_overwriteWithoutAsking);

		addViewerListeners();
		addFilter();

		initialize();
		setControl(container);
		Dialog.applyDialogFont(container);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(container, IHelpContextIds.PLUGIN_IMPORT_SECOND_PAGE);
	}

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

	protected Composite createInternationalizeList(Composite parent) {
		Composite container = createViewerContainer(parent, PDEUIMessages.InternationalizeWizard_PluginPage_internationalizeList);
		fSelectedViewer = createTableViewer(container, new SelectedContentProvider(), PDECore.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(PDEPlugin.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 IPluginModelBase findModel(String id) {
		for (int i = 0; i < fModels.length; i++) {
			String modelId = fModels[i].getPluginBase().getId();
			if (modelId != null && modelId.equals(id))
				return fModels[i];
		}
		return null;
	}

	private IFragmentModel[] findFragments(IPlugin 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(IPluginModelBase 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 IPluginModel) {
				IPluginLibrary[] libraries = model.getPluginBase().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(IPluginModelBase model, ArrayList selected, boolean addFragments) {

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

		if (addFragments) {
			if (model instanceof IPluginModel) {
				IFragmentModel[] fragments = findFragments(((IPluginModel) model).getPlugin());
				for (int i = 0; i < fragments.length; i++) {
					addPluginAndDependencies(fragments[i], selected, addFragments);
				}
			} else {
				IFragment fragment = ((IFragmentModel) model).getFragment();
				IPluginModelBase 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();
	}

	/* (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(PDEUIMessages.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(PDEUIMessages.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(PDEUIMessages.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(PDEUIMessages.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 createTemplateField(Composite parent) {
		Group container = createFilterContainer(parent, PDEUIMessages.InternationalizeWizard_PluginPage_template, PDEUIMessages.InternationalizeWizard_PluginPage_templateLabel);
		fTemplateText = createFilterText(container, NLSFragmentGenerator.PLUGIN_NAME_MACRO + ".nl1");
		fTemplateText.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				pageChanged();
			}
		});
		return container;
	}

	private Composite createScrollArea(Composite parent) {
		Group container = createFilterContainer(parent, PDEUIMessages.InternationalizeWizard_PluginPage_filter, PDEUIMessages.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(PDEUIMessages.InternationalizeWizard_PluginPage_templateError);
		} else if (fSelectedViewer.getTable().getItemCount() == 0) {
			setErrorMessage(PDEUIMessages.InternationalizeWizard_PluginPage_selectionError);
		} else {
			setErrorMessage(null);
		}

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

	private void updateCount() {
		fCountLabel.setText(NLS.bind(PDEUIMessages.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() {
		PDEPlugin.getDefault().getLabelProvider().disconnect(this);
		PDECore.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();
	}
}




package org.eclipse.pde.internal.ui.nls;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * Stores the list of BundlePluginModels and ExternalPluginModels to be passed to the
 * InternationalizeWizard. This class could also used to populate the list of locales
 * to which plug-ins will be internationalized.
 * 
 * @author Team Azure
 *
 */
public class InternationalizeModelTable {
	private List fModels;
	private List fPreSelected; //Models preselected by the user

	public InternationalizeModelTable() {
		fModels = new ArrayList();
		fPreSelected = new ArrayList();
	}

	/**
	 * Adds the model to the model table. Takes into consideration the specified
	 * selection.
	 * @param model
	 * @param selected
	 */
	public void addToModelTable(Object model, boolean selected) {
		if (selected)
			fPreSelected.add(model);
		else
			fModels.add(model);
	}

	/**
	 * Adds the model to the model table.
	 * @param model
	 */
	public void addModel(Object model) {
		fModels.add(model);
	}

	/**
	 * Removes the specified model from the model table.
	 * @param model
	 */
	public void removeModel(Object model) {
		fModels.remove(model);
	}

	/**
	 * 
	 * @return the number of models in the table
	 */
	public int getModelCount() {
		return fPreSelected.size() + fModels.size();
	}

	/**
	 * Returns the list of models stored in the model table
	 * @return the array of models
	 */
	public Object[] getModels() {
		return fModels.toArray();
	}

	/**
	 * Returns the list of preselected models stored in the model table
	 * @return the array of preselected models
	 */
	public Object[] getPreSelected() {
		return fPreSelected.toArray();
	}

	/**
	 * 
	 * @return whether or not the model table contains preselected models
	 */
	public boolean hasPreSelected() {
		return fPreSelected.size() > 0;
	}

	/**
	 * 
	 * @return whether or not the list of models is empty
	 */
	public boolean isEmpty() {
		return fModels.size() == 0;
	}
}




/**
 * 
 */
package org.eclipse.pde.internal.ui.nls;

import java.util.Map;
import java.util.regex.Pattern;
import org.eclipse.jface.viewers.*;
import org.eclipse.pde.internal.core.util.PatternConstructor;

public class AvailableFilter extends ViewerFilter {
	public static final String WILDCARD = "*"; //$NON-NLS-1$
	private Pattern fPattern;
	private final Map selected;
	private final ILabelProvider labelProvider;

	public AvailableFilter(Map selected, ILabelProvider labelProvider) {
		setPattern(WILDCARD);
		this.selected = selected;
		this.labelProvider = labelProvider;
	}

	public boolean select(Viewer viewer, Object parentElement, Object element) {
		// filter out any items that are currently selected
		// on a full refresh, these will have been added back to the list
		if (selected.containsKey(element))
			return false;

		String displayName = labelProvider.getText(element);
		return matches(element.toString()) || matches(displayName);
	}

	private boolean matches(String s) {
		return fPattern.matcher(s.toLowerCase()).matches();
	}

	public boolean setPattern(String pattern) {
		String newPattern = pattern.toLowerCase();

		if (!newPattern.endsWith(WILDCARD))
			newPattern += WILDCARD;
		if (!newPattern.startsWith(WILDCARD))
			newPattern = WILDCARD + newPattern;
		if (fPattern != null) {
			String oldPattern = fPattern.pattern();
			if (newPattern.equals(oldPattern))
				return false;
		}
		fPattern = PatternConstructor.createPattern(newPattern, true);
		return true;
	}
}

Return to bug 201998

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/LocaleLabelProvider.java (+38 lines)
1	package org.eclipse.pde.internal.ui.nls;
2
3	import java.util.Locale;
4	import org.eclipse.jface.viewers.ILabelProvider;
5	import org.eclipse.jface.viewers.ILabelProviderListener;
6	import org.eclipse.swt.graphics.Image;
7
8	public class LocaleLabelProvider implements ILabelProvider {
9
10	public Image getImage(Object element) {
11	return null;
12	}
13
14	public String getText(Object element) {
15	Locale locale = (Locale) element;
16	String country = " (" + locale.getDisplayCountry() + ")";
17	return locale.getDisplayLanguage() + (" ()".equals(country) ? "" : country);
18	}
19
20	public void addListener(ILabelProviderListener listener) {
21	// TODO Auto-generated method stub
22
23	}
24
25	public void dispose() {
26	// TODO Auto-generated method stub
27	}
28
29	public boolean isLabelProperty(Object element, String property) {
30	// TODO Auto-generated method stub
31	return false;
32	}
33
34	public void removeListener(ILabelProviderListener listener) {
35	// TODO Auto-generated method stub
36
37	}
38	}

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/InternationalizationWizardPage.java (+44 lines)
1	package org.eclipse.pde.internal.ui.nls;
2
3	import org.eclipse.jface.resource.ImageDescriptor;
4	import org.eclipse.jface.wizard.WizardPage;
5	import org.eclipse.swt.SWT;
6	import org.eclipse.swt.layout.GridData;
7	import org.eclipse.swt.layout.GridLayout;
8	import org.eclipse.swt.widgets.*;
9
10	public abstract class InternationalizationWizardPage extends WizardPage {
11
12	public InternationalizationWizardPage(String pageName) {
13	super(pageName);
14	}
15
16	public InternationalizationWizardPage(String pageName, String title, ImageDescriptor titleImage) {
17	super(pageName, title, titleImage);
18	}
19
20	protected Group createFilterContainer(Composite parent, String title, String label) {
21	Group container = new Group(parent, SWT.NONE);
22	GridLayout layout = new GridLayout(2, false);
23	layout.marginWidth = layout.marginHeight = 6;
24	container.setLayout(layout);
25
26	GridData gd = new GridData(GridData.FILL_HORIZONTAL);
27	gd.horizontalSpan = 3;
28	container.setLayoutData(gd);
29	container.setText(title);
30
31	Label templateLabel = new Label(container, SWT.NONE);
32	templateLabel.setText(label);
33	return container;
34	}
35
36	protected Text createFilterText(Composite parent, String initial) {
37	Text text = new Text(parent, SWT.BORDER);
38	text.setText(initial);
39	GridData gd = new GridData(GridData.FILL_HORIZONTAL);
40	text.setLayoutData(gd);
41	return text;
42	}
43
44	}

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/InternationalizeWizardOpenOperation.java (+64 lines)
1	package org.eclipse.pde.internal.ui.nls;
2
3	import org.eclipse.core.resources.ResourcesPlugin;
4	import org.eclipse.core.runtime.Assert;
5	import org.eclipse.core.runtime.OperationCanceledException;
6	import org.eclipse.core.runtime.jobs.IJobManager;
7	import org.eclipse.core.runtime.jobs.Job;
8	import org.eclipse.jface.dialogs.Dialog;
9	import org.eclipse.jface.window.Window;
10	import org.eclipse.jface.wizard.IWizardContainer;
11	import org.eclipse.jface.wizard.WizardDialog;
12	import org.eclipse.swt.custom.BusyIndicator;
13	import org.eclipse.swt.widgets.Shell;
14
15	/**
16	* A helper class to open an InternationalizeWizard dialog.
17	*
18	* @author Team Azure
19	*/
20	public class InternationalizeWizardOpenOperation {
21
22	private InternationalizeWizard fWizard;
23
24	public InternationalizeWizardOpenOperation(InternationalizeWizard wizard) {
25	Assert.isNotNull(wizard);
26	fWizard = wizard;
27	}
28
29	public int run(final Shell parent, final String dialogTitle) throws InterruptedException {
30	Assert.isNotNull(dialogTitle);
31	final IJobManager manager = Job.getJobManager();
32	final int[] result = new int[1];
33	final InterruptedException[] canceled = new InterruptedException[1];
34
35	Runnable r = new Runnable() {
36	public void run() {
37	try {
38	manager.beginRule(ResourcesPlugin.getWorkspace().getRoot(), null);
39
40	Dialog dialog = new WizardDialog(parent, fWizard);
41	dialog.create();
42
43	IWizardContainer wizardContainer = (IWizardContainer) dialog;
44	if (wizardContainer.getCurrentPage() == null) {
45	//Close the dialog if there are no pages
46	result[0] = Window.CANCEL;
47	} else {
48	//Open the wizard dialog
49	result[0] = dialog.open();
50	}
51
52	} catch (OperationCanceledException e) {
53	canceled[0] = new InterruptedException(e.getMessage());
54	} finally {
55	manager.endRule(ResourcesPlugin.getWorkspace().getRoot());
56	}
57	}
58	};
59	BusyIndicator.showWhile(parent.getDisplay(), r);
60	if (canceled[0] != null)
61	throw canceled[0];
62	return result[0];
63	}
64	}

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/InternationalizeAction.java (+79 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.internal.ui.nls;
12
13	import java.lang.reflect.InvocationTargetException;
14	import org.eclipse.jface.action.IAction;
15	import org.eclipse.jface.dialogs.MessageDialog;
16	import org.eclipse.jface.viewers.ISelection;
17	import org.eclipse.jface.viewers.IStructuredSelection;
18	import org.eclipse.pde.internal.ui.PDEPlugin;
19	import org.eclipse.pde.internal.ui.PDEUIMessages;
20	import org.eclipse.ui.*;
21
22	/**
23	* This action class is responsible for creating and initializing the
24	* InternationalizeWizard.
25	*
26	* @author Team Azure
27	*
28	*/
29	public class InternationalizeAction implements IWorkbenchWindowActionDelegate {
30
31	private IStructuredSelection fSelection;
32
33	public InternationalizeAction() {
34	}
35
36	public void run(IAction action) {
37	//Create an InternationalizeOperation on the workbench selection.
38	InternationalizeOperation runnable = new InternationalizeOperation(fSelection);
39	try {
40	PlatformUI.getWorkbench().getProgressService().busyCursorWhile(runnable);
41	} catch (InvocationTargetException e) {
42	} catch (InterruptedException e) {
43	} finally {
44	if (runnable.wasCanceled()) {
45	return;
46	}
47
48	/* Get the plugin model table containing the list of workspace and
49	* external plug-ins
50	*/
51	InternationalizeModelTable pluginTable = runnable.getPluginTable();
52
53	if (!pluginTable.isEmpty()) {
54
55	InternationalizeWizard wizard = new InternationalizeWizard(action, pluginTable);
56	wizard.init(PlatformUI.getWorkbench(), fSelection);
57
58	//Create an operation to start and run the wizard
59	InternationalizeWizardOpenOperation op = new InternationalizeWizardOpenOperation(wizard);
60	try {
61	op.run(PDEPlugin.getActiveWorkbenchShell(), ""); //$NON-NLS-1$
62	} catch (final InterruptedException irex) {
63	}
64	} else {
65	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), PDEUIMessages.InternationalizeAction_internationalizeTitle, PDEUIMessages.InternationalizeAction_internationalizeMessage);
66	}
67	}
68	}
69
70	public void selectionChanged(IAction action, ISelection selection) {
71	fSelection = (IStructuredSelection) selection;
72	}
73
74	public void dispose() {
75	}
76
77	public void init(IWorkbenchWindow window) {
78	}
79	}

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/InternationalizeWizardLocalePage.java (+500 lines)
1	/**
2	*
3	*/
4	package org.eclipse.pde.internal.ui.nls;
5
6	import java.util.*;
7	import java.util.List;
8	import org.eclipse.core.runtime.*;
9	import org.eclipse.jface.dialogs.Dialog;
10	import org.eclipse.jface.dialogs.IDialogSettings;
11	import org.eclipse.jface.layout.GridLayoutFactory;
12	import org.eclipse.jface.viewers.*;
13	import org.eclipse.jface.wizard.IWizardContainer;
14	import org.eclipse.osgi.util.NLS;
15	import org.eclipse.pde.core.IModelProviderEvent;
16	import org.eclipse.pde.core.IModelProviderListener;
17	import org.eclipse.pde.internal.core.PDECore;
18	import org.eclipse.pde.internal.ui.*;
19	import org.eclipse.pde.internal.ui.elements.DefaultContentProvider;
20	import org.eclipse.pde.internal.ui.util.SWTUtil;
21	import org.eclipse.pde.internal.ui.wizards.ListUtil;
22	import org.eclipse.swt.SWT;
23	import org.eclipse.swt.custom.ScrolledComposite;
24	import org.eclipse.swt.events.*;
25	import org.eclipse.swt.layout.GridData;
26	import org.eclipse.swt.layout.GridLayout;
27	import org.eclipse.swt.widgets.*;
28	import org.eclipse.ui.PlatformUI;
29	import org.eclipse.ui.progress.WorkbenchJob;
30
31	/**
32	* @author Robbie
33	*
34	*/
35	public class InternationalizeWizardLocalePage extends InternationalizationWizardPage implements IModelProviderListener {
36
37	public static final String PAGE_NAME = "InternationalizeWizardLocalePage"; //$NON-NLS-1$
38
39	protected Locale[] fModels = new Locale[0];
40	private String fLocation;
41
42	protected TableViewer fSelectedListViewer;
43	private boolean fRefreshNeeded = true;
44
45	private Label fCountLabel;
46	private TableViewer fAvailableListViewer;
47
48	// this job is used to delay the full filter refresh for 200 milliseconds in case the user is still typing
49	private WorkbenchJob fFilterJob;
50	private Text fFilterText;
51	private AvailableFilter fFilter;
52
53	// fSelected is used to track the selection in a HashMap so we can efficiently
54	// filter selected items out of the available item list
55	private HashMap fSelected;
56	// used to block the selection listeners from updating button enablement when programatically removing items
57	private boolean fBlockSelectionListeners;
58	private Button fAddButton;
59	private Button fAddAllButton;
60	private Button fRemoveButton;
61	private Button fRemoveAllButton;
62
63	private InternationalizeModelTable fInternationalizeModelTable;
64
65	private class ContentProvider extends DefaultContentProvider implements IStructuredContentProvider {
66	public Object[] getElements(Object inputElement) {
67	return ((InternationalizeModelTable) inputElement).getModels();
68	}
69	}
70
71	public InternationalizeWizardLocalePage(InternationalizeModelTable modelTable, String pageName) {
72	super(pageName);
73	setTitle(PDEUIMessages.InternationalizeWizard_LocalePage_pageTitle);
74	setDescription(PDEUIMessages.InternationalizeWizard_LocalePage_pageDescription);
75
76	PDEPlugin.getDefault().getLabelProvider().connect(this);
77	PDECore.getDefault().getModelManager().getExternalModelManager().addModelProviderListener(this);
78
79	fInternationalizeModelTable = modelTable;
80	fSelected = new HashMap();
81
82	IWizardContainer container = getContainer();
83	if (container != null)
84	container.updateButtons();
85	}
86
87	private void addFilter() {
88	fFilter = new AvailableFilter(fSelected, new LocaleLabelProvider());
89	fAvailableListViewer.addFilter(fFilter);
90	fFilterJob = new WorkbenchJob("FilterJob") { //$NON-NLS-1$
91	public IStatus runInUIThread(IProgressMonitor monitor) {
92	handleFilter();
93	return Status.OK_STATUS;
94	}
95	};
96	fFilterJob.setSystem(true);
97	}
98
99	private void handleFilter() {
100	boolean changed = false;
101	String newFilter;
102	if (fFilterText == null \|\| (newFilter = fFilterText.getText().trim()).length() == 0)
103	newFilter = AvailableFilter.WILDCARD;
104	changed = fFilter.setPattern(newFilter);
105	if (changed) {
106	fAvailableListViewer.getTable().setRedraw(false);
107	fAvailableListViewer.refresh();
108	fAvailableListViewer.getTable().setRedraw(true);
109	updateButtonEnablement(false, false);
110	}
111	}
112
113	/* (non-Javadoc)
114	* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
115	*/
116	public void createControl(Composite parent) {
117	Composite container = new Composite(parent, SWT.NONE);
118	GridLayout layout = new GridLayout();
119	layout.numColumns = 3;
120	layout.makeColumnsEqualWidth = false;
121	layout.horizontalSpacing = 5;
122	layout.verticalSpacing = 20;
123	container.setLayout(layout);
124
125	createScrollArea(container);
126	createAvailableList(container).setLayoutData(new GridData(GridData.FILL_BOTH));
127	createButtonArea(container);
128	createLocaleList(container).setLayoutData(new GridData(GridData.FILL_BOTH));
129	updateCount();
130
131	// create container for buttons
132	Composite buttonContainer = new Composite(container, SWT.NONE);
133	buttonContainer.setLayout(GridLayoutFactory.fillDefaults().create());
134
135	addViewerListeners();
136	addFilter();
137
138	initialize();
139	setControl(container);
140	Dialog.applyDialogFont(container);
141	PlatformUI.getWorkbench().getHelpSystem().setHelp(container, IHelpContextIds.PLUGIN_IMPORT_SECOND_PAGE);
142	}
143
144	protected Composite createLocaleList(Composite parent) {
145	Composite container = new Composite(parent, SWT.NONE);
146	GridLayout layout = new GridLayout();
147	layout.marginWidth = 0;
148	layout.marginHeight = 0;
149	container.setLayout(layout);
150	container.setLayoutData(new GridData(GridData.FILL_BOTH));
151
152	Label label = new Label(container, SWT.NONE);
153	label.setText(PDEUIMessages.InternationalizeWizard_LocalePage_internationalizeList);
154
155	Table table = new Table(container, SWT.BORDER \| SWT.MULTI \| SWT.V_SCROLL);
156	GridData gd = new GridData(GridData.FILL_BOTH);
157	gd.widthHint = 225;
158	table.setLayoutData(gd);
159
160	fSelectedListViewer = new TableViewer(table);
161	fSelectedListViewer.setLabelProvider(new LocaleLabelProvider());
162	fSelectedListViewer.setContentProvider(new ContentProvider());
163	fSelectedListViewer.setComparator(ListUtil.NAME_COMPARATOR);
164	return container;
165	}
166
167	protected boolean isRefreshNeeded() {
168	if (fRefreshNeeded) {
169	fRefreshNeeded = false;
170	return true;
171	}
172	if (fLocation == null) {
173	return true;
174	}
175	return false;
176	}
177
178	protected void addLocale(Locale model, ArrayList selected) {
179	if (!selected.contains(model)) {
180	selected.add(model);
181	}
182	}
183
184	public List getLocalesForInternationalization() {
185	TableItem[] items = fSelectedListViewer.getTable().getItems();
186	List result = new ArrayList();
187	for (int i = 0; i < items.length; i++) {
188	result.add(items[i].getData());
189	}
190	return result;
191	}
192
193	public void storeSettings() {
194	IDialogSettings settings = getDialogSettings();
195	}
196
197	/* (non-Javadoc)
198	* @see org.eclipse.pde.core.IModelProviderListener#modelsChanged(org.eclipse.pde.core.IModelProviderEvent)
199	*/
200	public void modelsChanged(IModelProviderEvent event) {
201	fRefreshNeeded = true;
202	}
203
204	private void initialize() {
205	updateButtonEnablement(true, true);
206	setPageComplete(false);
207	}
208
209	private void addViewerListeners() {
210	fAvailableListViewer.addDoubleClickListener(new IDoubleClickListener() {
211	public void doubleClick(DoubleClickEvent event) {
212	handleAdd();
213	}
214	});
215
216	fSelectedListViewer.addDoubleClickListener(new IDoubleClickListener() {
217	public void doubleClick(DoubleClickEvent event) {
218	handleRemove();
219	}
220	});
221
222	fAvailableListViewer.addSelectionChangedListener(new ISelectionChangedListener() {
223	public void selectionChanged(SelectionChangedEvent event) {
224	if (!fBlockSelectionListeners)
225	updateSelectionBasedEnablement(event.getSelection(), true);
226	}
227	});
228
229	fSelectedListViewer.addSelectionChangedListener(new ISelectionChangedListener() {
230	public void selectionChanged(SelectionChangedEvent event) {
231	if (!fBlockSelectionListeners)
232	updateSelectionBasedEnablement(event.getSelection(), false);
233	}
234	});
235
236	fFilterText.addModifyListener(new ModifyListener() {
237	public void modifyText(ModifyEvent e) {
238	fFilterJob.cancel();
239	fFilterJob.schedule(200);
240	}
241	});
242
243	}
244
245	private Composite createAvailableList(Composite parent) {
246	Composite container = new Composite(parent, SWT.NONE);
247	GridLayout layout = new GridLayout();
248	layout.marginWidth = 0;
249	layout.marginHeight = 0;
250	container.setLayout(layout);
251	container.setLayoutData(new GridData());
252
253	Label label = new Label(container, SWT.NONE);
254	label.setText(PDEUIMessages.InternationalizeWizard_LocalePage_availableList);
255
256	Table table = new Table(container, SWT.BORDER \| SWT.MULTI \| SWT.V_SCROLL);
257	GridData gd = new GridData(GridData.FILL_BOTH);
258	gd.heightHint = 200;
259	gd.widthHint = 225;
260	table.setLayoutData(gd);
261
262	fAvailableListViewer = new TableViewer(table);
263	fAvailableListViewer.setLabelProvider(new LocaleLabelProvider());
264	fAvailableListViewer.setContentProvider(new ContentProvider());
265	fAvailableListViewer.setInput(fInternationalizeModelTable);
266	fAvailableListViewer.setComparator(ListUtil.NAME_COMPARATOR);
267
268	return container;
269	}
270
271	private Composite createButtonArea(Composite parent) {
272	ScrolledComposite comp = new ScrolledComposite(parent, SWT.V_SCROLL \| SWT.H_SCROLL);
273	GridLayout layout = new GridLayout();
274	layout.marginWidth = layout.marginHeight = 0;
275	comp.setLayoutData(new GridData(GridData.FILL_VERTICAL));
276	Composite container = new Composite(comp, SWT.NONE);
277	layout = new GridLayout();
278	layout.marginWidth = 0;
279	layout.marginTop = 50;
280	container.setLayout(layout);
281	GridData gd = new GridData(GridData.FILL_VERTICAL);
282	gd.verticalIndent = 15;
283	container.setLayoutData(gd);
284
285	fAddButton = new Button(container, SWT.PUSH);
286	fAddButton.setText(PDEUIMessages.ImportWizard_DetailedPage_add);
287	fAddButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
288	fAddButton.addSelectionListener(new SelectionAdapter() {
289	public void widgetSelected(SelectionEvent e) {
290	handleAdd();
291	}
292	});
293	SWTUtil.setButtonDimensionHint(fAddButton);
294
295	fAddAllButton = new Button(container, SWT.PUSH);
296	fAddAllButton.setText(PDEUIMessages.ImportWizard_DetailedPage_addAll);
297	fAddAllButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
298	fAddAllButton.addSelectionListener(new SelectionAdapter() {
299	public void widgetSelected(SelectionEvent e) {
300	handleAddAll();
301	}
302	});
303	SWTUtil.setButtonDimensionHint(fAddAllButton);
304
305	fRemoveButton = new Button(container, SWT.PUSH);
306	fRemoveButton.setText(PDEUIMessages.ImportWizard_DetailedPage_remove);
307	fRemoveButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
308	fRemoveButton.addSelectionListener(new SelectionAdapter() {
309	public void widgetSelected(SelectionEvent e) {
310	handleRemove();
311	}
312	});
313	SWTUtil.setButtonDimensionHint(fRemoveButton);
314
315	fRemoveAllButton = new Button(container, SWT.PUSH);
316	fRemoveAllButton.setText(PDEUIMessages.ImportWizard_DetailedPage_removeAll);
317	fRemoveAllButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
318	fRemoveAllButton.addSelectionListener(new SelectionAdapter() {
319	public void widgetSelected(SelectionEvent e) {
320	handleRemoveAll();
321	}
322	});
323	SWTUtil.setButtonDimensionHint(fRemoveAllButton);
324
325	fCountLabel = new Label(container, SWT.NONE);
326	fCountLabel.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_CENTER));
327	comp.setContent(container);
328	comp.setMinHeight(250);
329	comp.setExpandHorizontal(true);
330	comp.setExpandVertical(true);
331	return container;
332	}
333
334	private Composite createScrollArea(Composite parent) {
335	Group container = createFilterContainer(parent, PDEUIMessages.InternationalizeWizard_LocalePage_filter, PDEUIMessages.ImportWizard_DetailedPage_search);
336	fFilterText = createFilterText(container, ""); //$NON-NLS-1$
337	return container;
338	}
339
340	protected void refreshPage() {
341	fSelectedListViewer.getTable().removeAll();
342	fSelected = new HashMap();
343	fAvailableListViewer.refresh();
344	pageChanged();
345	}
346
347	protected void pageChanged() {
348	pageChanged(false, false);
349	}
350
351	protected void pageChanged(boolean doAddEnablement, boolean doRemoveEnablement) {
352	if (fSelectedListViewer.getTable().getItemCount() == 0) {
353	setErrorMessage(PDEUIMessages.InternationalizeWizard_LocalePage_selectionError);
354	} else {
355	setErrorMessage(null);
356	}
357
358	updateCount();
359	updateButtonEnablement(doAddEnablement, doRemoveEnablement);
360	setPageComplete(fSelectedListViewer.getTable().getItemCount() > 0);
361	}
362
363	private void updateCount() {
364	fCountLabel.setText(NLS.bind(PDEUIMessages.ImportWizard_DetailedPage_count, (new String[] {new Integer(fSelectedListViewer.getTable().getItemCount()).toString(), new Integer(fAvailableListViewer.getTable().getItemCount() + fSelectedListViewer.getTable().getItemCount()).toString()})));
365	fCountLabel.getParent().layout();
366	}
367
368	private void updateButtonEnablement(boolean doAddEnablement, boolean doRemoveEnablement) {
369	int availableCount = fAvailableListViewer.getTable().getItemCount();
370	int importCount = fSelectedListViewer.getTable().getItemCount();
371
372	if (doAddEnablement)
373	updateSelectionBasedEnablement(fAvailableListViewer.getSelection(), true);
374	if (doRemoveEnablement)
375	updateSelectionBasedEnablement(fSelectedListViewer.getSelection(), false);
376
377	fAddAllButton.setEnabled(availableCount > 0);
378	fRemoveAllButton.setEnabled(importCount > 0);
379	}
380
381	private void updateSelectionBasedEnablement(ISelection theSelection, boolean available) {
382	if (available)
383	fAddButton.setEnabled(!theSelection.isEmpty());
384	else
385	fRemoveButton.setEnabled(!theSelection.isEmpty());
386	}
387
388	private void handleAdd() {
389	IStructuredSelection ssel = (IStructuredSelection) fAvailableListViewer.getSelection();
390	if (ssel.size() > 0) {
391	Table table = fAvailableListViewer.getTable();
392	int index = table.getSelectionIndices()[0];
393	Object[] selection = ssel.toArray();
394	setBlockSelectionListeners(true);
395	setRedraw(false);
396	for (int i = 0; i < selection.length; i++) {
397	doAdd(selection[i]);
398	}
399	setRedraw(true);
400	setBlockSelectionListeners(false);
401	table.setSelection(index < table.getItemCount() ? index : table.getItemCount() - 1);
402	pageChanged(true, false);
403	}
404	}
405
406	private void handleAddAll() {
407	TableItem[] items = fAvailableListViewer.getTable().getItems();
408
409	ArrayList data = new ArrayList();
410	for (int i = 0; i < items.length; i++) {
411	data.add(items[i].getData());
412	}
413	if (data.size() > 0) {
414	Object[] datas = data.toArray();
415	setBlockSelectionListeners(true);
416	setRedraw(false);
417	for (int i = 0; i < datas.length; i++) {
418	doAdd(datas[i]);
419	}
420	setRedraw(true);
421	setBlockSelectionListeners(false);
422	pageChanged(true, false);
423	}
424	}
425
426	private void handleRemove() {
427	IStructuredSelection ssel = (IStructuredSelection) fSelectedListViewer.getSelection();
428	if (ssel.size() > 0) {
429	Table table = fSelectedListViewer.getTable();
430	int index = table.getSelectionIndices()[0];
431	Object[] selection = ssel.toArray();
432	setBlockSelectionListeners(true);
433	setRedraw(false);
434	for (int i = 0; i < selection.length; i++) {
435	doRemove(selection[i]);
436	}
437	setRedraw(true);
438	setBlockSelectionListeners(false);
439	table.setSelection(index < table.getItemCount() ? index : table.getItemCount() - 1);
440	pageChanged(false, true);
441	}
442	}
443
444	private void doAdd(Object o) {
445	fInternationalizeModelTable.removeModel(o);
446	fSelectedListViewer.add(o);
447	fAvailableListViewer.remove(o);
448	fSelected.put(o, null);
449	}
450
451	private void doRemove(Object o) {
452	fInternationalizeModelTable.addModel(o);
453	fSelected.remove(o);
454	fSelectedListViewer.remove(o);
455	fAvailableListViewer.add(o);
456	}
457
458	// used to prevent flicker during operations that move items between lists
459	private void setRedraw(boolean redraw) {
460	fAvailableListViewer.getTable().setRedraw(redraw);
461	fSelectedListViewer.getTable().setRedraw(redraw);
462	}
463
464	private void handleRemoveAll() {
465	TableItem[] items = fSelectedListViewer.getTable().getItems();
466
467	ArrayList data = new ArrayList();
468	for (int i = 0; i < items.length; i++) {
469	data.add(items[i].getData());
470	}
471	if (data.size() > 0) {
472	Object[] datas = data.toArray();
473	setBlockSelectionListeners(true);
474	setRedraw(false);
475	for (int i = 0; i < datas.length; i++) {
476	doRemove(datas[i]);
477	}
478	setRedraw(true);
479	setBlockSelectionListeners(false);
480	pageChanged(false, true);
481	}
482	}
483
484	public void dispose() {
485	PDEPlugin.getDefault().getLabelProvider().disconnect(this);
486	PDECore.getDefault().getModelManager().getExternalModelManager().removeModelProviderListener(this);
487	}
488
489	private void setBlockSelectionListeners(boolean blockSelectionListeners) {
490	fBlockSelectionListeners = blockSelectionListeners;
491	}
492
493	public boolean isCurrentPage() {
494	return super.isCurrentPage();
495	}
496
497	public boolean canFlipToNextPage() {
498	return false;
499	}
500	}

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/NLSFragmentGenerator.java (+268 lines)
1	package org.eclipse.pde.internal.ui.nls;
2
3	import java.io.*;
4	import java.lang.reflect.InvocationTargetException;
5	import java.util.*;
6	import java.util.zip.ZipEntry;
7	import java.util.zip.ZipFile;
8	import org.eclipse.core.resources.*;
9	import org.eclipse.core.runtime.*;
10	import org.eclipse.jface.dialogs.MessageDialog;
11	import org.eclipse.jface.wizard.IWizardContainer;
12	import org.eclipse.osgi.util.NLS;
13	import org.eclipse.pde.core.plugin.IPluginModelBase;
14	import org.eclipse.pde.internal.core.TargetPlatformHelper;
15	import org.eclipse.pde.internal.core.plugin.ExternalPluginModelBase;
16	import org.eclipse.pde.internal.ui.PDEPlugin;
17	import org.eclipse.pde.internal.ui.PDEUIMessages;
18	import org.eclipse.pde.internal.ui.wizards.IProjectProvider;
19	import org.eclipse.pde.internal.ui.wizards.plugin.FragmentFieldData;
20	import org.eclipse.pde.internal.ui.wizards.plugin.NewProjectCreationOperation;
21
22	/**
23	*
24	* Generates the fragment projects for the list of selected plug-ins.
25	* Each fragment contains a series of properties files specific to the locales
26	* the user selected. For example plugin_fr.properties for the french locale
27	* selection. The generated locale-specific properties files contain the same
28	* key-value pairs as the properties file of the initial plug-in.
29	*
30	* @author Team Azure
31	*
32	*/
33	public class NLSFragmentGenerator {
34
35	public static final String PLUGIN_NAME_MACRO = "${plugin_name}"; //$NON-NLS-1$
36
37	private static final double LATEST_ECLIPSE_VERSION = 3.4;
38
39	private static final String ZERO = "0"; //$NON-NLS-1$
40	private static final String PERIOD = "."; //$NON-NLS-1$
41	private static final String MIN_MINOR = ZERO; //$NON-NLS-1$
42	private static final String MAX_MINOR = "9"; //$NON-NLS-1$
43	private static final String LEFT_SQUARE_BRACKET = "["; //$NON-NLS-1$
44	private static final String RIGHT_PARENTHESIS = ")"; //$NON-NLS-1$
45	private static final String DEFAULT_VERSION = "1.0.0"; //$NON-NLS-1$
46	private static final String VERSION_FORMAT_WITH_QUALIFIER = "\\d+\\.\\d+\\.\\d+\\..+"; //$NON-NLS-1$
47	private static final String PROPERTIES_FILE_EXTENSION = ".properties"; //$NON-NLS-1$
48	private static final String LOCALE_PROPERTIES_FILE_PREFIX = "plugin_"; //$NON-NLS-1$
49	private static final String JAR_SUFFIX = ".jar"; //$NON-NLS-1$
50	private static final String PROPERTIES_FILE_NAME = "plugin.properties"; //$NON-NLS-1$
51	private static final String PATH_SEPERATOR = "\\"; //$NON-NLS-1$
52
53	private FragmentFieldData fFragmentData;
54	private IProjectProvider fProjectProvider;
55	private IWizardContainer container;
56	private String template;
57
58	private final List plugins;
59
60	private final List locales;
61
62	private final boolean overwriteWithoutAsking;
63
64	public NLSFragmentGenerator(String template, List plugins, List locales, IWizardContainer container, boolean overwriteWithoutAsking) {
65	this.plugins = plugins;
66	this.locales = locales;
67	this.container = container;
68	this.template = template;
69	this.overwriteWithoutAsking = overwriteWithoutAsking;
70	}
71
72	public boolean generate() {
73	return internationalizePlugins(plugins, locales);
74	}
75
76	/**
77	* Creates an NL fragment project along with the locale specific properties
78	* files.
79	*/
80	private boolean internationalizePlugins(List plugins, List locales) {
81	for (Iterator it = plugins.iterator(); it.hasNext();) {
82	IPluginModelBase plugin = (IPluginModelBase) it.next();
83	if (!createNLFragment(plugin))
84	return false;
85
86	IProject currentFragmentProject = ResourcesPlugin.getWorkspace().getRoot().getProject(pluginName(plugin));
87
88	for (Iterator iter = locales.iterator(); iter.hasNext();) {
89	Locale locale = (Locale) iter.next();
90	createLocaleSpecificPropertiesFile(currentFragmentProject, plugin, locale);
91	}
92	}
93
94	return true;
95	}
96
97	/**
98	* Creates a fragment project for the specified plug-in and populates
99	* the field data.
100	* @param plugin
101	*/
102	private boolean createNLFragment(IPluginModelBase plugin) {
103	final String name = pluginName(plugin);
104	IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
105	if (!overwriteWithoutAsking && project.exists()) {
106	boolean overwrite = MessageDialog.openConfirm(PDEPlugin.getActiveWorkbenchShell(), PDEUIMessages.InternationalizeWizard_NLSFragmentGenerator_overwriteTitle, NLS.bind(PDEUIMessages.InternationalizeWizard_NLSFragmentGenerator_overwriteMessage, name));
107	if (!overwrite)
108	return false;
109	}
110
111	if (project.exists()) {
112	try {
113	project.delete(true, new NullProgressMonitor());
114	} catch (CoreException e1) {
115	// TODO Auto-generated catch block
116	e1.printStackTrace();
117	}
118	}
119
120	fFragmentData = new FragmentFieldData();
121
122	populateFieldData(plugin);
123
124	fProjectProvider = new IProjectProvider() {
125	public String getProjectName() {
126	return name;
127	}
128
129	public IProject getProject() {
130	return ResourcesPlugin.getWorkspace().getRoot().getProject(getProjectName());
131	}
132
133	public IPath getLocationPath() {
134	return new Path(Platform.getLocation().toOSString());
135	}
136	};
137
138	try {
139	container.run(false, true, new NewProjectCreationOperation(fFragmentData, fProjectProvider, null));
140	} catch (InvocationTargetException e) {
141	e.printStackTrace();
142	} catch (InterruptedException e) {
143	e.printStackTrace();
144	}
145	return true;
146	}
147
148	private String pluginName(IPluginModelBase plugin) {
149	return template.replace(PLUGIN_NAME_MACRO, plugin.getPluginBase().getId());
150	}
151
152	/**
153	* The fields are populated based on the plug-in attributes. Some fields
154	* are set to their default values.
155	*/
156	private void populateFieldData(IPluginModelBase plugin) {
157
158	fFragmentData.setId(pluginName(plugin));
159	fFragmentData.setVersion(DEFAULT_VERSION);
160	fFragmentData.setMatch(0);
161
162	fFragmentData.setPluginId(plugin.getPluginBase().getId());
163	fFragmentData.setPluginVersion(incrementRelease(plugin.getPluginBase().getVersion()));
164	fFragmentData.setName(pluginName(plugin) + " Fragment"); //$NON-NLS-1$
165	fFragmentData.setProvider(""); //$NON-NLS-1$
166	fFragmentData.setSimple(true);
167
168	if (!(plugin instanceof ExternalPluginModelBase)) {
169	fFragmentData.setSourceFolderName("src"); //$NON-NLS-1$
170	fFragmentData.setOutputFolderName("bin"); //$NON-NLS-1$
171	}
172
173	fFragmentData.setLegacy(false);
174	fFragmentData.setTargetVersion(Double.toString(ensureTargetVersionCompatibility(TargetPlatformHelper.getTargetVersion())));
175	fFragmentData.setHasBundleStructure(true);
176	fFragmentData.setOSGiFramework(null);
177	fFragmentData.setWorkingSets(null);
178	}
179
180	/**
181	* Adjusts the plug-in's version to reflect the required
182	* fragment-host bundle-version range. For example,
183	* fragment-host's bundle-version range would be: "[1.0.0, 1.1.0)"
184	* if the host's version is 1.0.0
185	* @param oldVersion
186	* @return adjusted plug-in version
187	*/
188	private String incrementRelease(String oldVersion) {
189	if (oldVersion.matches(VERSION_FORMAT_WITH_QUALIFIER)) {
190	oldVersion = oldVersion.substring(0, oldVersion.lastIndexOf(PERIOD));
191	}
192
193	String newVersion = LEFT_SQUARE_BRACKET + oldVersion + ',';
194	String oldMinor = oldVersion.substring(oldVersion.indexOf(PERIOD) + 1, oldVersion.lastIndexOf(PERIOD));
195
196	if (oldMinor.compareTo(MAX_MINOR) == 0) {
197	String major = Integer.toString(Integer.parseInt(oldVersion.substring(0, oldVersion.indexOf(PERIOD))) + 1);
198	newVersion += major + PERIOD + MIN_MINOR + PERIOD + ZERO + RIGHT_PARENTHESIS;
199	} else {
200	String major = oldVersion.substring(0, oldVersion.indexOf(PERIOD));
201	String newMinor = Integer.toString(Integer.parseInt(oldMinor) + 1);
202	newVersion += major + PERIOD + newMinor + PERIOD + ZERO + RIGHT_PARENTHESIS;
203	}
204
205	return newVersion;
206	}
207
208	/**
209	* Creates a locale specific properties file within the fragment project
210	* based on the content of the host plug-in's properties file.
211	* @param fragmentProject
212	* @param locale
213	*/
214	private void createLocaleSpecificPropertiesFile(IProject fragmentProject, IPluginModelBase plugin, Locale locale) {
215	IFile localeProperties = fragmentProject.getFile(LOCALE_PROPERTIES_FILE_PREFIX + locale + PROPERTIES_FILE_EXTENSION);
216
217	//Case 1: External plug-in
218	if (plugin instanceof ExternalPluginModelBase) {
219	String installLocation = plugin.getInstallLocation();
220	//Case 1a: External plug-in is a jar file
221	if (installLocation.endsWith(JAR_SUFFIX)) {
222	try {
223	ZipFile zf = new ZipFile(installLocation);
224	ZipEntry zfe = zf.getEntry(PROPERTIES_FILE_NAME);
225	InputStream is = zf.getInputStream(zfe);
226	localeProperties.create(is, false, null);
227	} catch (Exception e) {
228	e.printStackTrace();
229	}
230	}
231	//Case 1b: External plug-in has a folder structure
232	else {
233	File propertiesFileLocation = new File(installLocation + PATH_SEPERATOR + PROPERTIES_FILE_NAME);
234	try {
235	FileInputStream is = new FileInputStream(propertiesFileLocation);
236	localeProperties.create(is, false, null);
237	} catch (Exception e) {
238	e.printStackTrace();
239	}
240	}
241	}
242	//Case 2: Workspace plug-in
243	else {
244	IFile pluginProperties = plugin.getUnderlyingResource().getProject().getFile(PROPERTIES_FILE_NAME);
245
246	if (!localeProperties.exists()) {
247	try {
248	pluginProperties.copy(localeProperties.getFullPath(), false, null);
249
250	} catch (Exception e) {
251	e.printStackTrace();
252	}
253	}
254	}
255	}
256
257	/**
258	* Ensures that the target version is compatible.
259	* @param targetVersion
260	* @return target version
261	*/
262	private double ensureTargetVersionCompatibility(double targetVersion) {
263	if (targetVersion < 3.0) {
264	return LATEST_ECLIPSE_VERSION;
265	}
266	return targetVersion;
267	}
268	}

Added Link Here

(-)src/org/eclipse/pde/internal/ui/nls/AvailableFilter.java (+52 lines)
1	/**
2	*
3	*/
4	package org.eclipse.pde.internal.ui.nls;
5
6	import java.util.Map;
7	import java.util.regex.Pattern;
8	import org.eclipse.jface.viewers.*;
9	import org.eclipse.pde.internal.core.util.PatternConstructor;
10
11	public class AvailableFilter extends ViewerFilter {
12	public static final String WILDCARD = "*"; //$NON-NLS-1$
13	private Pattern fPattern;
14	private final Map selected;
15	private final ILabelProvider labelProvider;
16
17	public AvailableFilter(Map selected, ILabelProvider labelProvider) {
18	setPattern(WILDCARD);
19	this.selected = selected;
20	this.labelProvider = labelProvider;
21	}
22
23	public boolean select(Viewer viewer, Object parentElement, Object element) {
24	// filter out any items that are currently selected
25	// on a full refresh, these will have been added back to the list
26	if (selected.containsKey(element))
27	return false;
28
29	String displayName = labelProvider.getText(element);
30	return matches(element.toString()) \|\| matches(displayName);
31	}
32
33	private boolean matches(String s) {
34	return fPattern.matcher(s.toLowerCase()).matches();
35	}
36
37	public boolean setPattern(String pattern) {
38	String newPattern = pattern.toLowerCase();
39
40	if (!newPattern.endsWith(WILDCARD))
41	newPattern += WILDCARD;
42	if (!newPattern.startsWith(WILDCARD))
43	newPattern = WILDCARD + newPattern;
44	if (fPattern != null) {
45	String oldPattern = fPattern.pattern();
46	if (newPattern.equals(oldPattern))
47	return false;
48	}
49	fPattern = PatternConstructor.createPattern(newPattern, true);
50	return true;
51	}
52	}