| /********************************************************************* |
| * Copyright (c) 2009, 2012 SpringSource, a division of VMware, Inc. |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| **********************************************************************/ |
| |
| package org.eclipse.virgo.ide.ui.editors; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| |
| import org.eclipse.jdt.launching.JavaRuntime; |
| import org.eclipse.jdt.launching.environments.IExecutionEnvironment; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.preference.PreferenceDialog; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.pde.core.IModelChangedEvent; |
| import org.eclipse.pde.core.plugin.IPluginModelBase; |
| import org.eclipse.pde.internal.core.ibundle.IBundle; |
| import org.eclipse.pde.internal.core.ibundle.IBundleModel; |
| import org.eclipse.pde.internal.core.ibundle.IManifestHeader; |
| import org.eclipse.pde.internal.core.text.bundle.ExecutionEnvironment; |
| import org.eclipse.pde.internal.core.text.bundle.RequiredExecutionEnvironmentHeader; |
| import org.eclipse.pde.internal.ui.PDEPlugin; |
| import org.eclipse.pde.internal.ui.PDEPluginImages; |
| import org.eclipse.pde.internal.ui.PDEUIMessages; |
| import org.eclipse.pde.internal.ui.editor.FormLayoutFactory; |
| import org.eclipse.pde.internal.ui.editor.PDEFormPage; |
| import org.eclipse.pde.internal.ui.editor.TableSection; |
| import org.eclipse.pde.internal.ui.editor.context.InputContextManager; |
| import org.eclipse.pde.internal.ui.editor.plugin.BundleInputContext; |
| import org.eclipse.pde.internal.ui.parts.EditableTablePart; |
| import org.eclipse.pde.internal.ui.parts.TablePart; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.ui.actions.ActionFactory; |
| import org.eclipse.ui.dialogs.ElementListSelectionDialog; |
| import org.eclipse.ui.dialogs.PreferencesUtil; |
| import org.eclipse.ui.forms.IFormColors; |
| import org.eclipse.ui.forms.events.HyperlinkEvent; |
| import org.eclipse.ui.forms.events.IHyperlinkListener; |
| import org.eclipse.ui.forms.widgets.FormToolkit; |
| import org.eclipse.ui.forms.widgets.Hyperlink; |
| import org.eclipse.ui.forms.widgets.Section; |
| import org.eclipse.ui.forms.widgets.TableWrapData; |
| import org.osgi.framework.Constants; |
| |
| /** |
| * Adapted from PDE's <code>ExcecutionEnvironmentSection</code>. * |
| * |
| * @author Christian Dupuis |
| * @author Steffen Pingel |
| */ |
| public class BundleExecutionEnvironmentSection extends TableSection { |
| |
| private TableViewer fEETable; |
| |
| private Action fRemoveAction; |
| |
| private Action fAddAction; |
| |
| class EELabelProvider extends LabelProvider { |
| |
| private final Image fImage; |
| |
| public EELabelProvider() { |
| this.fImage = PDEPluginImages.DESC_JAVA_LIB_OBJ.createImage(); |
| } |
| |
| @Override |
| public Image getImage(Object element) { |
| return this.fImage; |
| } |
| |
| @Override |
| public String getText(Object element) { |
| if (element instanceof IExecutionEnvironment) { |
| return ((IExecutionEnvironment) element).getId(); |
| } |
| return super.getText(element); |
| } |
| |
| @Override |
| public void dispose() { |
| if (this.fImage != null) { |
| this.fImage.dispose(); |
| } |
| super.dispose(); |
| } |
| } |
| |
| class ContentProvider implements IStructuredContentProvider { |
| |
| public void dispose() { |
| } |
| |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| } |
| |
| public Object[] getElements(Object inputElement) { |
| if (inputElement instanceof IBundleModel) { |
| IBundleModel model = (IBundleModel) inputElement; |
| IBundle bundle = model.getBundle(); |
| IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT); |
| if (header instanceof RequiredExecutionEnvironmentHeader) { |
| return ((RequiredExecutionEnvironmentHeader) header).getEnvironments(); |
| } |
| } |
| return new Object[0]; |
| } |
| } |
| |
| public BundleExecutionEnvironmentSection(PDEFormPage page, Composite parent) { |
| super(page, parent, Section.DESCRIPTION, |
| new String[] { PDEUIMessages.RequiredExecutionEnvironmentSection_add, PDEUIMessages.RequiredExecutionEnvironmentSection_remove, |
| PDEUIMessages.RequiredExecutionEnvironmentSection_up, PDEUIMessages.RequiredExecutionEnvironmentSection_down }); |
| createClient(getSection(), page.getEditor().getToolkit()); |
| } |
| |
| @Override |
| protected void createClient(Section section, FormToolkit toolkit) { |
| section.setText(PDEUIMessages.RequiredExecutionEnvironmentSection_title); |
| if (isFragment()) { |
| section.setDescription(PDEUIMessages.RequiredExecutionEnvironmentSection_fragmentDesc); |
| } else { |
| section.setDescription(PDEUIMessages.RequiredExecutionEnvironmentSection_pluginDesc); |
| } |
| |
| section.setLayout(FormLayoutFactory.createClearTableWrapLayout(false, 1)); |
| |
| TableWrapData data = new TableWrapData(TableWrapData.FILL_GRAB); |
| section.setLayoutData(data); |
| |
| Composite container = createClientContainer(section, 2, toolkit); |
| EditableTablePart tablePart = getTablePart(); |
| tablePart.setEditable(isEditable()); |
| |
| createViewerPartControl(container, SWT.FULL_SELECTION | SWT.MULTI, 2, toolkit); |
| this.fEETable = tablePart.getTableViewer(); |
| this.fEETable.setContentProvider(new ContentProvider()); |
| this.fEETable.setLabelProvider(PDEPlugin.getDefault().getLabelProvider()); |
| |
| Hyperlink link = toolkit.createHyperlink(container, PDEUIMessages.BuildExecutionEnvironmentSection_configure, SWT.NONE); |
| link.setForeground(toolkit.getColors().getColor(IFormColors.TITLE)); |
| link.addHyperlinkListener(new IHyperlinkListener() { |
| |
| public void linkEntered(HyperlinkEvent e) { |
| } |
| |
| public void linkExited(HyperlinkEvent e) { |
| } |
| |
| public void linkActivated(HyperlinkEvent e) { |
| showPreferencePage(new String[] { "org.eclipse.jdt.debug.ui.jreProfiles" }, PDEPlugin.getActiveWorkbenchShell()); //$NON-NLS-1$ |
| } |
| }); |
| GridData gd = new GridData(); |
| gd.horizontalSpan = 2; |
| link.setLayoutData(gd); |
| |
| makeActions(); |
| |
| IBundleModel model = getBundleModel(); |
| if (model != null) { |
| this.fEETable.setInput(model); |
| model.addModelChangedListener(this); |
| } |
| toolkit.paintBordersFor(container); |
| section.setClient(container); |
| } |
| |
| public static boolean showPreferencePage(String[] pageIds, final Shell shell) { |
| final PreferenceDialog dialog = PreferencesUtil.createPreferenceDialogOn(shell, pageIds[0], pageIds, null); |
| return dialog.open() == Window.OK; |
| } |
| |
| @Override |
| public void dispose() { |
| IBundleModel model = getBundleModel(); |
| if (model != null) { |
| model.removeModelChangedListener(this); |
| } |
| } |
| |
| @Override |
| public void refresh() { |
| this.fEETable.refresh(); |
| updateButtons(); |
| } |
| |
| @Override |
| protected void buttonSelected(int index) { |
| switch (index) { |
| case 0: |
| handleAdd(); |
| break; |
| case 1: |
| handleRemove(); |
| break; |
| case 2: |
| handleUp(); |
| break; |
| case 3: |
| handleDown(); |
| break; |
| } |
| } |
| |
| @Override |
| protected void fillContextMenu(IMenuManager manager) { |
| manager.add(this.fAddAction); |
| if (!this.fEETable.getSelection().isEmpty()) { |
| manager.add(new Separator()); |
| manager.add(this.fRemoveAction); |
| } |
| getPage().getPDEEditor().getContributor().contextMenuAboutToShow(manager); |
| } |
| |
| private void makeActions() { |
| this.fAddAction = new Action(PDEUIMessages.RequiredExecutionEnvironmentSection_add) { |
| |
| @Override |
| public void run() { |
| handleAdd(); |
| } |
| }; |
| this.fAddAction.setEnabled(isEditable()); |
| |
| this.fRemoveAction = new Action(PDEUIMessages.NewManifestEditor_LibrarySection_remove) { |
| |
| @Override |
| public void run() { |
| handleRemove(); |
| } |
| }; |
| this.fRemoveAction.setEnabled(isEditable()); |
| } |
| |
| private void updateButtons() { |
| Table table = this.fEETable.getTable(); |
| int count = table.getItemCount(); |
| boolean canMoveUp = count > 0 && table.getSelection().length == 1 && table.getSelectionIndex() > 0; |
| boolean canMoveDown = count > 0 && table.getSelection().length == 1 && table.getSelectionIndex() < count - 1; |
| |
| TablePart tablePart = getTablePart(); |
| tablePart.setButtonEnabled(0, isEditable()); |
| tablePart.setButtonEnabled(1, isEditable() && table.getSelection().length > 0); |
| tablePart.setButtonEnabled(2, isEditable() && canMoveUp); |
| tablePart.setButtonEnabled(3, isEditable() && canMoveDown); |
| } |
| |
| private void handleDown() { |
| int selection = this.fEETable.getTable().getSelectionIndex(); |
| swap(selection, selection + 1); |
| } |
| |
| private void handleUp() { |
| int selection = this.fEETable.getTable().getSelectionIndex(); |
| swap(selection, selection - 1); |
| } |
| |
| public void swap(int index1, int index2) { |
| RequiredExecutionEnvironmentHeader header = getHeader(); |
| header.swap(index1, index2); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void handleRemove() { |
| IStructuredSelection ssel = (IStructuredSelection) this.fEETable.getSelection(); |
| if (ssel.size() > 0) { |
| Iterator iter = ssel.iterator(); |
| while (iter.hasNext()) { |
| Object object = iter.next(); |
| if (object instanceof ExecutionEnvironment) { |
| getHeader().removeExecutionEnvironment((ExecutionEnvironment) object); |
| } |
| } |
| } |
| } |
| |
| private void handleAdd() { |
| ElementListSelectionDialog dialog = new ElementListSelectionDialog(PDEPlugin.getActiveWorkbenchShell(), new EELabelProvider()); |
| dialog.setElements(getEnvironments()); |
| dialog.setAllowDuplicates(false); |
| dialog.setMultipleSelection(true); |
| dialog.setTitle(PDEUIMessages.RequiredExecutionEnvironmentSection_dialog_title); |
| dialog.setMessage(PDEUIMessages.RequiredExecutionEnvironmentSection_dialogMessage); |
| if (dialog.open() == Window.OK) { |
| addExecutionEnvironments(dialog.getResult()); |
| } |
| } |
| |
| private void addExecutionEnvironments(Object[] result) { |
| IManifestHeader header = getHeader(); |
| if (header == null) { |
| StringBuffer buffer = new StringBuffer(); |
| for (Object element : result) { |
| String id = null; |
| if (element instanceof IExecutionEnvironment) { |
| id = ((IExecutionEnvironment) element).getId(); |
| } else if (element instanceof ExecutionEnvironment) { |
| id = ((ExecutionEnvironment) element).getName(); |
| } else { |
| continue; |
| } |
| if (buffer.length() > 0) { |
| buffer.append(","); //$NON-NLS-1$ |
| buffer.append(getLineDelimiter()); |
| buffer.append(" "); //$NON-NLS-1$ |
| } |
| buffer.append(id); |
| } |
| getBundle().setHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT, buffer.toString()); |
| } else { |
| RequiredExecutionEnvironmentHeader ee = (RequiredExecutionEnvironmentHeader) header; |
| ee.addExecutionEnvironments(result); |
| } |
| } |
| |
| private String getLineDelimiter() { |
| BundleInputContext inputContext = getBundleContext(); |
| if (inputContext != null) { |
| return inputContext.getLineDelimiter(); |
| } |
| return System.getProperty("line.separator"); //$NON-NLS-1$ |
| } |
| |
| @SuppressWarnings("unchecked") |
| private Object[] getEnvironments() { |
| RequiredExecutionEnvironmentHeader header = getHeader(); |
| IExecutionEnvironment[] envs = JavaRuntime.getExecutionEnvironmentsManager().getExecutionEnvironments(); |
| if (header == null) { |
| return envs; |
| } |
| ArrayList list = new ArrayList(); |
| for (int i = 0; i < envs.length; i++) { |
| if (!header.hasExecutionEnvironment(envs[i])) { |
| list.add(envs[i]); |
| } |
| } |
| return list.toArray(); |
| } |
| |
| @Override |
| public void modelChanged(IModelChangedEvent e) { |
| if (e.getChangeType() == IModelChangedEvent.WORLD_CHANGED) { |
| markStale(); |
| } else if (e.getChangeType() == IModelChangedEvent.REMOVE) { |
| Object[] objects = e.getChangedObjects(); |
| for (Object element : objects) { |
| Table table = this.fEETable.getTable(); |
| if (element instanceof ExecutionEnvironment) { |
| int index = table.getSelectionIndex(); |
| this.fEETable.remove(element); |
| table.setSelection(index < table.getItemCount() ? index : table.getItemCount() - 1); |
| } |
| } |
| updateButtons(); |
| } else if (e.getChangeType() == IModelChangedEvent.INSERT) { |
| Object[] objects = e.getChangedObjects(); |
| for (Object element : objects) { |
| if (element instanceof ExecutionEnvironment) { |
| this.fEETable.add(element); |
| } |
| } |
| if (objects.length > 0) { |
| this.fEETable.setSelection(new StructuredSelection(objects[objects.length - 1])); |
| } |
| updateButtons(); |
| } else if (Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT.equals(e.getChangedProperty())) { |
| refresh(); |
| } |
| } |
| |
| private BundleInputContext getBundleContext() { |
| InputContextManager manager = getPage().getPDEEditor().getContextManager(); |
| return (BundleInputContext) manager.findContext(BundleInputContext.CONTEXT_ID); |
| } |
| |
| private IBundle getBundle() { |
| IBundleModel model = getBundleModel(); |
| return model == null ? null : model.getBundle(); |
| } |
| |
| private IBundleModel getBundleModel() { |
| BundleInputContext context = getBundleContext(); |
| return context == null ? null : (IBundleModel) context.getModel(); |
| } |
| |
| protected RequiredExecutionEnvironmentHeader getHeader() { |
| IBundle bundle = getBundle(); |
| if (bundle == null) { |
| return null; |
| } |
| IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT); |
| if (header instanceof RequiredExecutionEnvironmentHeader) { |
| return (RequiredExecutionEnvironmentHeader) header; |
| } |
| return null; |
| } |
| |
| protected boolean isFragment() { |
| InputContextManager manager = getPage().getPDEEditor().getContextManager(); |
| IPluginModelBase model = (IPluginModelBase) manager.getAggregateModel(); |
| return model.isFragmentModel(); |
| } |
| |
| @Override |
| public boolean doGlobalAction(String actionId) { |
| if (!isEditable()) { |
| return false; |
| } |
| |
| if (actionId.equals(ActionFactory.DELETE.getId())) { |
| handleRemove(); |
| return true; |
| } |
| |
| if (actionId.equals(ActionFactory.CUT.getId())) { |
| // delete here and let the editor transfer |
| // the selection to the clipboard |
| handleRemove(); |
| return false; |
| } |
| |
| if (actionId.equals(ActionFactory.PASTE.getId())) { |
| doPaste(); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| @Override |
| protected boolean canPaste(Object target, Object[] objects) { |
| RequiredExecutionEnvironmentHeader header = getHeader(); |
| for (Object element : objects) { |
| if (element instanceof ExecutionEnvironment) { |
| String env = ((ExecutionEnvironment) element).getName(); |
| if (header == null || !header.hasElement(env)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| protected void selectionChanged(IStructuredSelection selection) { |
| getPage().getPDEEditor().setSelection(selection); |
| if (getPage().getModel().isEditable()) { |
| updateButtons(); |
| } |
| } |
| |
| @Override |
| protected void doPaste(Object target, Object[] objects) { |
| addExecutionEnvironments(objects); |
| } |
| |
| } |
