| /********************************************************************* |
| * 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 org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jface.dialogs.IMessageProvider; |
| import org.eclipse.pde.core.IBaseModel; |
| import org.eclipse.pde.core.IModelChangeProvider; |
| import org.eclipse.pde.core.IModelChangedEvent; |
| import org.eclipse.pde.core.plugin.IPluginBase; |
| import org.eclipse.pde.core.plugin.IPluginModelBase; |
| import org.eclipse.pde.core.plugin.PluginRegistry; |
| import org.eclipse.pde.internal.core.ibundle.IBundle; |
| import org.eclipse.pde.internal.core.ibundle.IBundleModel; |
| import org.eclipse.pde.internal.ui.PDEPlugin; |
| import org.eclipse.pde.internal.ui.PDEUIMessages; |
| import org.eclipse.pde.internal.ui.editor.FormEntryAdapter; |
| import org.eclipse.pde.internal.ui.editor.FormLayoutFactory; |
| import org.eclipse.pde.internal.ui.editor.PDEFormPage; |
| import org.eclipse.pde.internal.ui.editor.PDESection; |
| import org.eclipse.pde.internal.ui.editor.context.InputContextManager; |
| import org.eclipse.pde.internal.ui.editor.plugin.BundleInputContext; |
| import org.eclipse.pde.internal.ui.editor.plugin.ManifestEditor; |
| import org.eclipse.pde.internal.ui.editor.validation.ControlValidationUtility; |
| import org.eclipse.pde.internal.ui.editor.validation.TextValidator; |
| import org.eclipse.pde.internal.ui.parts.FormEntry; |
| import org.eclipse.swt.dnd.Clipboard; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.forms.widgets.FormToolkit; |
| import org.eclipse.ui.forms.widgets.Section; |
| import org.eclipse.ui.forms.widgets.TableWrapData; |
| |
| /** |
| * This abstract class is essentially a copy of GeneralInfoSection from PDE with visibility increased to "protected" as |
| * required to re-use this code without unnecessary copying into subclasses. This class should not be further modified |
| * to keep the separation between PDE and non-PDE code. |
| * |
| * @author Christian Dupuis |
| */ |
| public abstract class AbstractPdeGeneralInfoSection extends PDESection { |
| |
| private static String PLATFORM_FILTER = "Eclipse-PlatformFilter"; //$NON-NLS-1$ |
| |
| protected FormEntry fIdEntry; |
| |
| protected FormEntry fVersionEntry; |
| |
| protected FormEntry fNameEntry; |
| |
| protected FormEntry fProviderEntry; |
| |
| protected FormEntry fPlatformFilterEntry; |
| |
| protected TextValidator fIdEntryValidator; |
| |
| protected TextValidator fVersionEntryValidator; |
| |
| protected TextValidator fNameEntryValidator; |
| |
| protected TextValidator fProviderEntryValidator; |
| |
| protected TextValidator fPlatformEntryValidator; |
| |
| private IPluginModelBase fModel; |
| |
| public AbstractPdeGeneralInfoSection(PDEFormPage page, Composite parent) { |
| super(page, parent, Section.DESCRIPTION); |
| createClient(getSection(), page.getEditor().getToolkit()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.pde.internal.ui.neweditor.PDESection#createClient(org.eclipse.ui.forms.widgets.Section, |
| * org.eclipse.ui.forms.widgets.FormToolkit) |
| */ |
| @Override |
| protected void createClient(Section section, FormToolkit toolkit) { |
| section.setText(PDEUIMessages.ManifestEditor_PluginSpecSection_title); |
| section.setLayout(FormLayoutFactory.createClearTableWrapLayout(false, 1)); |
| TableWrapData data = new TableWrapData(TableWrapData.FILL_GRAB); |
| section.setLayoutData(data); |
| |
| section.setDescription(getSectionDescription()); |
| Composite client = toolkit.createComposite(section); |
| client.setLayout(FormLayoutFactory.createSectionClientTableWrapLayout(false, 3)); |
| section.setClient(client); |
| |
| IActionBars actionBars = getPage().getPDEEditor().getEditorSite().getActionBars(); |
| createIDEntry(client, toolkit, actionBars); |
| createVersionEntry(client, toolkit, actionBars); |
| createNameEntry(client, toolkit, actionBars); |
| createProviderEntry(client, toolkit, actionBars); |
| if (isBundle() && ((ManifestEditor) getPage().getEditor()).isEquinox()) { |
| createPlatformFilterEntry(client, toolkit, actionBars); |
| } |
| createSpecificControls(client, toolkit, actionBars); |
| toolkit.paintBordersFor(client); |
| |
| addListeners(); |
| } |
| |
| protected abstract String getSectionDescription(); |
| |
| protected abstract void createSpecificControls(Composite parent, FormToolkit toolkit, IActionBars actionBars); |
| |
| protected IPluginBase getPluginBase() { |
| IBaseModel model = getPage().getPDEEditor().getAggregateModel(); |
| return ((IPluginModelBase) model).getPluginBase(); |
| } |
| |
| /** |
| * Not using the aggregate model from the form editor because it is a different model instance from the one used by |
| * the bundle error reporter. Things get out of sync between the form validator and source validator |
| * |
| * @return |
| */ |
| protected IPluginModelBase getModelBase() { |
| // Find the model only on the first call |
| if (this.fModel == null) { |
| this.fModel = PluginRegistry.findModel(getProject()); |
| } |
| return this.fModel; |
| } |
| |
| protected boolean isBundle() { |
| return getBundleContext() != null; |
| } |
| |
| private BundleInputContext getBundleContext() { |
| InputContextManager manager = getPage().getPDEEditor().getContextManager(); |
| return (BundleInputContext) manager.findContext(BundleInputContext.CONTEXT_ID); |
| } |
| |
| protected IBundle getBundle() { |
| BundleInputContext context = getBundleContext(); |
| if (context != null) { |
| IBundleModel model = (IBundleModel) context.getModel(); |
| return model.getBundle(); |
| } |
| return null; |
| } |
| |
| protected void createIDEntry(Composite client, FormToolkit toolkit, IActionBars actionBars) { |
| this.fIdEntry = new FormEntry(client, toolkit, PDEUIMessages.GeneralInfoSection_id, null, false); |
| this.fIdEntry.setFormEntryListener(new FormEntryAdapter(this, actionBars) { |
| |
| @Override |
| public void textValueChanged(FormEntry entry) { |
| try { |
| getPluginBase().setId(entry.getValue()); |
| } catch (CoreException e) { |
| PDEPlugin.logException(e); |
| } |
| } |
| }); |
| this.fIdEntry.setEditable(isEditable()); |
| // Create validator |
| this.fIdEntryValidator = new TextValidator(getManagedForm(), this.fIdEntry.getText(), getProject(), true) { |
| |
| @Override |
| protected boolean validateControl() { |
| return validateIdEntry(); |
| } |
| }; |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean validateIdEntry() { |
| // Value must be specified |
| return ControlValidationUtility.validateRequiredField(this.fIdEntry.getText().getText(), this.fIdEntryValidator, IMessageProvider.ERROR); |
| } |
| |
| protected void createVersionEntry(Composite client, FormToolkit toolkit, IActionBars actionBars) { |
| this.fVersionEntry = new FormEntry(client, toolkit, PDEUIMessages.GeneralInfoSection_version, null, false); |
| this.fVersionEntry.setFormEntryListener(new FormEntryAdapter(this, actionBars) { |
| |
| @Override |
| public void textValueChanged(FormEntry entry) { |
| try { |
| getPluginBase().setVersion(entry.getValue()); |
| } catch (CoreException e) { |
| PDEPlugin.logException(e); |
| } |
| } |
| }); |
| this.fVersionEntry.setEditable(isEditable()); |
| // Create validator |
| this.fVersionEntryValidator = new TextValidator(getManagedForm(), this.fVersionEntry.getText(), getProject(), true) { |
| |
| @Override |
| protected boolean validateControl() { |
| return validateVersionEntry(); |
| } |
| }; |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean validateVersionEntry() { |
| // Value must be specified |
| if (ControlValidationUtility.validateRequiredField(this.fVersionEntry.getText().getText(), this.fVersionEntryValidator, |
| IMessageProvider.ERROR) == false) { |
| return false; |
| } |
| // Value must be a valid version |
| return ControlValidationUtility.validateVersionField(this.fVersionEntry.getText().getText(), this.fVersionEntryValidator); |
| } |
| |
| protected void createNameEntry(Composite client, FormToolkit toolkit, IActionBars actionBars) { |
| this.fNameEntry = new FormEntry(client, toolkit, PDEUIMessages.GeneralInfoSection_name, null, false); |
| this.fNameEntry.setFormEntryListener(new FormEntryAdapter(this, actionBars) { |
| |
| @Override |
| public void textValueChanged(FormEntry entry) { |
| try { |
| getPluginBase().setName(entry.getValue()); |
| } catch (CoreException e) { |
| PDEPlugin.logException(e); |
| } |
| } |
| }); |
| this.fNameEntry.setEditable(isEditable()); |
| // Create validator |
| this.fNameEntryValidator = new TextValidator(getManagedForm(), this.fNameEntry.getText(), getProject(), true) { |
| |
| @Override |
| protected boolean validateControl() { |
| return validateNameEntry(); |
| } |
| }; |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean validateNameEntry() { |
| // Value must be specified |
| if (ControlValidationUtility.validateRequiredField(this.fNameEntry.getText().getText(), this.fNameEntryValidator, |
| IMessageProvider.ERROR) == false) { |
| return false; |
| } |
| // Value must be externalized |
| return ControlValidationUtility.validateTranslatableField(this.fNameEntry.getText().getText(), this.fNameEntryValidator, getModelBase(), |
| getProject()); |
| } |
| |
| protected void createProviderEntry(Composite client, FormToolkit toolkit, IActionBars actionBars) { |
| this.fProviderEntry = new FormEntry(client, toolkit, PDEUIMessages.GeneralInfoSection_provider, null, false); |
| this.fProviderEntry.setFormEntryListener(new FormEntryAdapter(this, actionBars) { |
| |
| @Override |
| public void textValueChanged(FormEntry entry) { |
| try { |
| getPluginBase().setProviderName(entry.getValue()); |
| } catch (CoreException e) { |
| PDEPlugin.logException(e); |
| } |
| } |
| }); |
| this.fProviderEntry.setEditable(isEditable()); |
| // Create validator |
| this.fProviderEntryValidator = new TextValidator(getManagedForm(), this.fProviderEntry.getText(), getProject(), true) { |
| |
| @Override |
| protected boolean validateControl() { |
| return validateProviderEntry(); |
| } |
| }; |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean validateProviderEntry() { |
| // No validation required for an optional field |
| if (this.fProviderEntry.getText().getText().length() == 0) { |
| return true; |
| } |
| // Value must be externalized |
| return ControlValidationUtility.validateTranslatableField(this.fProviderEntry.getText().getText(), this.fProviderEntryValidator, |
| getModelBase(), getProject()); |
| } |
| |
| private void createPlatformFilterEntry(Composite client, FormToolkit toolkit, IActionBars actionBars) { |
| this.fPlatformFilterEntry = new FormEntry(client, toolkit, PDEUIMessages.GeneralInfoSection_platformFilter, null, false); |
| this.fPlatformFilterEntry.setFormEntryListener(new FormEntryAdapter(this, actionBars) { |
| |
| @Override |
| public void textValueChanged(FormEntry entry) { |
| getBundle().setHeader(PLATFORM_FILTER, AbstractPdeGeneralInfoSection.this.fPlatformFilterEntry.getValue()); |
| } |
| }); |
| this.fPlatformFilterEntry.setEditable(isEditable()); |
| // Create validator |
| this.fPlatformEntryValidator = new TextValidator(getManagedForm(), this.fPlatformFilterEntry.getText(), getProject(), true) { |
| |
| @Override |
| protected boolean validateControl() { |
| return validatePlatformEntry(); |
| } |
| }; |
| } |
| |
| /** |
| * @return |
| */ |
| private boolean validatePlatformEntry() { |
| // No validation required for an optional field |
| if (this.fPlatformFilterEntry.getText().getText().length() == 0) { |
| return true; |
| } |
| // Value must match the current environment and contain valid syntax |
| return ControlValidationUtility.validatePlatformFilterField(this.fPlatformFilterEntry.getText().getText(), this.fPlatformEntryValidator); |
| } |
| |
| @Override |
| public void commit(boolean onSave) { |
| this.fIdEntry.commit(); |
| this.fVersionEntry.commit(); |
| this.fNameEntry.commit(); |
| this.fProviderEntry.commit(); |
| if (this.fPlatformFilterEntry != null) { |
| this.fPlatformFilterEntry.commit(); |
| } |
| super.commit(onSave); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.pde.internal.ui.editor.PDESection#modelChanged(org.eclipse.pde.core.IModelChangedEvent) |
| */ |
| @Override |
| public void modelChanged(IModelChangedEvent e) { |
| if (e.getChangeType() == IModelChangedEvent.WORLD_CHANGED) { |
| markStale(); |
| return; |
| } |
| refresh(); |
| if (e.getChangeType() == IModelChangedEvent.CHANGE) { |
| Object obj = e.getChangedObjects()[0]; |
| if (obj instanceof IPluginBase) { |
| String property = e.getChangedProperty(); |
| if (property != null && property.equals(getPage().getPDEEditor().getTitleProperty())) { |
| getPage().getPDEEditor().updateTitle(); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void refresh() { |
| IPluginModelBase model = (IPluginModelBase) getPage().getPDEEditor().getContextManager().getAggregateModel(); |
| IPluginBase pluginBase = model.getPluginBase(); |
| this.fIdEntry.setValue(pluginBase.getId(), true); |
| this.fNameEntry.setValue(pluginBase.getName(), true); |
| this.fVersionEntry.setValue(pluginBase.getVersion(), true); |
| this.fProviderEntry.setValue(pluginBase.getProviderName(), true); |
| if (this.fPlatformFilterEntry != null) { |
| IBundle bundle = getBundle(); |
| if (bundle != null) { |
| this.fPlatformFilterEntry.setValue(bundle.getHeader(PLATFORM_FILTER), true); |
| } |
| } |
| getPage().getPDEEditor().updateTitle(); |
| super.refresh(); |
| } |
| |
| @Override |
| public void cancelEdit() { |
| this.fIdEntry.cancelEdit(); |
| this.fNameEntry.cancelEdit(); |
| this.fVersionEntry.cancelEdit(); |
| this.fProviderEntry.cancelEdit(); |
| if (this.fPlatformFilterEntry != null) { |
| this.fPlatformFilterEntry.cancelEdit(); |
| } |
| super.cancelEdit(); |
| } |
| |
| @Override |
| public void dispose() { |
| removeListeners(); |
| super.dispose(); |
| } |
| |
| protected void removeListeners() { |
| IBaseModel model = getPage().getModel(); |
| if (model instanceof IModelChangeProvider) { |
| ((IModelChangeProvider) model).removeModelChangedListener(this); |
| } |
| } |
| |
| protected void addListeners() { |
| IBaseModel model = getPage().getModel(); |
| if (model instanceof IModelChangeProvider) { |
| ((IModelChangeProvider) model).addModelChangedListener(this); |
| } |
| } |
| |
| @Override |
| public boolean canPaste(Clipboard clipboard) { |
| Display d = getSection().getDisplay(); |
| return d.getFocusControl() instanceof Text; |
| } |
| |
| } |
