| /** |
| * <copyright> |
| * |
| * Copyright (c) 2012, 2012 SAP AG. |
| * 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: |
| * SAP AG - initial API, implementation and documentation |
| * mwenz - Bug 388211 - New plug-in with Graphiti editor wizard adds not needed dependency to org.eclipse.ui |
| * |
| * </copyright> |
| */ |
| package org.eclipse.graphiti.tools.newprojectwizard.internal; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Locale; |
| import java.util.ResourceBundle; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.jface.wizard.Wizard; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.pde.core.plugin.IPluginBase; |
| import org.eclipse.pde.core.plugin.IPluginElement; |
| import org.eclipse.pde.core.plugin.IPluginExtension; |
| import org.eclipse.pde.core.plugin.IPluginModelBase; |
| import org.eclipse.pde.core.plugin.IPluginModelFactory; |
| import org.eclipse.pde.core.plugin.IPluginReference; |
| import org.eclipse.pde.ui.IFieldData; |
| import org.eclipse.pde.ui.IPluginFieldData; |
| import org.eclipse.pde.ui.templates.OptionTemplateSection; |
| import org.eclipse.pde.ui.templates.PluginReference; |
| import org.eclipse.pde.ui.templates.StringOption; |
| import org.eclipse.pde.ui.templates.TemplateOption; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.widgets.Button; |
| |
| public class GraphitiEditorTemplateSection extends OptionTemplateSection { |
| |
| private static final String KEY_DT_ID = "diagramTypeId"; //$NON-NLS-1$ |
| private static final String KEY_DT_NAME = "diagramTypeName"; //$NON-NLS-1$ |
| private static final String KEY_DT_TYPE = "diagramTypeType"; //$NON-NLS-1$ |
| private static final String KEY_DT_DESCRIPTION = "diagramTypeDescription"; //$NON-NLS-1$ |
| |
| private static final String KEY_DTP_CLASS_NAME = "diagramTypeProviderClassName"; //$NON-NLS-1$ |
| private static final String KEY_DTP_ID = "diagramTypeProviderId"; //$NON-NLS-1$ |
| private static final String KEY_DTP_NAME = "diagramTypeProviderName"; //$NON-NLS-1$ |
| private static final String KEY_DTP_DESCRIPTION = "diagramTypeProviderDescription"; //$NON-NLS-1$ |
| |
| private static final String KEY_FEATURE_PROVIDER_CLASS_NAME = "featureProviderClassName"; //$NON-NLS-1$ |
| private static final String KEY_USE_PATTERNS = "usePatterns"; //$NON-NLS-1$ |
| |
| private static final String KEY_USE_SHAPE_DOMAIN_OBJECT = "useShapeDomainObject"; //$NON-NLS-1$ |
| private static final String KEY_SHAPE_DOMAIN_OBJECT_CLASS_NAME = "shapeDomainObjectClassName"; //$NON-NLS-1$ |
| private static final String KEY_SHAPE_DOMAIN_OBJECT_CLASS_NAME_SHORT = "shapeDomainObjectClassNameShort"; //$NON-NLS-1$ |
| |
| private static final String KEY_USE_CONNECTION_DOMAIN_OBJECT = "useConnectionDomainObject"; //$NON-NLS-1$ |
| private static final String KEY_CONNECTION_DOMAIN_OBJECT_CLASS_NAME = "connectionDomainObjectClassName"; //$NON-NLS-1$ |
| private static final String KEY_CONNECTION_DOMAIN_OBJECT_CLASS_NAME_SHORT = "connectionDomainObjectClassNameShort"; //$NON-NLS-1$ |
| |
| private static final String KEY_GENERATE_ACTIVATOR = "generateActivator"; //$NON-NLS-1$ |
| |
| private SelectTypeOption shapeDomainObjectOption; |
| private SelectTypeOption connectionDomainObjectOption; |
| |
| public GraphitiEditorTemplateSection() { |
| super(); |
| setPageCount(2); |
| createOptions(); |
| } |
| |
| private void createOptions() { |
| |
| GroupOption diagramTypeGroupOption = addGroupOption(0, |
| Messages.GraphitiEditorTemplateSection_groupNameDiagramType); |
| addGroupedOption(KEY_DT_ID, Messages.GraphitiEditorTemplateSection_fieldNameId, null, 0, diagramTypeGroupOption); |
| addGroupedOption(KEY_DT_NAME, Messages.GraphitiEditorTemplateSection_fieldNameName, null, 0, |
| diagramTypeGroupOption); |
| addGroupedOption(KEY_DT_TYPE, Messages.GraphitiEditorTemplateSection_fieldNameType, null, 0, |
| diagramTypeGroupOption); |
| TemplateOption diagramTypeDescriptionOption = addGroupedOption(KEY_DT_DESCRIPTION, |
| Messages.GraphitiEditorTemplateSection_fieldNameDescription, "", 0, //$NON-NLS-1$ |
| diagramTypeGroupOption); |
| diagramTypeDescriptionOption.setRequired(false); |
| |
| GroupOption diagramTypeProviderGroupOption = addGroupOption(0, |
| Messages.GraphitiEditorTemplateSection_groupNameDiagramTypeProvider); |
| addGroupedOption(KEY_PACKAGE_NAME, Messages.GraphitiEditorTemplateSection_fieldNamePackageName, null, 0, |
| diagramTypeProviderGroupOption); |
| addGroupedOption(KEY_DTP_ID, Messages.GraphitiEditorTemplateSection_fieldNameId, null, 0, |
| diagramTypeProviderGroupOption); |
| addGroupedOption(KEY_DTP_NAME, Messages.GraphitiEditorTemplateSection_fieldNameName, null, 0, |
| diagramTypeProviderGroupOption); |
| addGroupedOption(KEY_DTP_CLASS_NAME, Messages.GraphitiEditorTemplateSection_fieldNameClassName, null, 0, |
| diagramTypeProviderGroupOption); |
| TemplateOption diagramTypeProviderDescriptionOption = addGroupedOption(KEY_DTP_DESCRIPTION, |
| Messages.GraphitiEditorTemplateSection_fieldNameDescription, "", //$NON-NLS-1$ |
| 0, diagramTypeProviderGroupOption); |
| diagramTypeProviderDescriptionOption.setRequired(false); |
| |
| GroupOption featureProviderGroupOption = addGroupOption(0, |
| Messages.GraphitiEditorTemplateSection_groupNameFeatureProvider); |
| addGroupedOption(KEY_FEATURE_PROVIDER_CLASS_NAME, Messages.GraphitiEditorTemplateSection_fieldNameClassName, |
| null, 0, featureProviderGroupOption); |
| addGroupedOption(KEY_USE_PATTERNS, Messages.GraphitiEditorTemplateSection_fieldNameUsePatterns, false, 0, |
| featureProviderGroupOption, null); |
| |
| final GroupOption shapeDomainObjectGroupOption = addGroupOption(1, |
| Messages.GraphitiEditorTemplateSection_groupNameShapeDomainObject); |
| addGroupedOption(KEY_USE_SHAPE_DOMAIN_OBJECT, |
| Messages.GraphitiEditorTemplateSection_fieldNameUseShapeDomainObject, false, 1, |
| shapeDomainObjectGroupOption, new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| Button source = (Button) e.getSource(); |
| boolean selection = source.getSelection(); |
| shapeDomainObjectOption.setRequired(selection); |
| shapeDomainObjectOption.setEnabled(selection); |
| if (!selection) { |
| shapeDomainObjectOption.setText(""); |
| } |
| validateOptions(shapeDomainObjectGroupOption); |
| } |
| }); |
| shapeDomainObjectOption = addSelectTypeOption(KEY_SHAPE_DOMAIN_OBJECT_CLASS_NAME, |
| Messages.GraphitiEditorTemplateSection_fieldNameShapeDomainObject, null, 1, |
| shapeDomainObjectGroupOption); |
| shapeDomainObjectOption.setRequired(false); |
| |
| final GroupOption connectionDomainObjectGroupOption = addGroupOption(1, |
| Messages.GraphitiEditorTemplateSection_groupNameConnectionDomainObject); |
| addGroupedOption(KEY_USE_CONNECTION_DOMAIN_OBJECT, |
| Messages.GraphitiEditorTemplateSection_fieldNameUseConenctionDomainObject, false, 1, |
| connectionDomainObjectGroupOption, new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| Button source = (Button) e.getSource(); |
| boolean selection = source.getSelection(); |
| connectionDomainObjectOption.setRequired(selection); |
| connectionDomainObjectOption.setEnabled(selection); |
| if (!selection) { |
| connectionDomainObjectOption.setText(""); |
| } |
| validateOptions(connectionDomainObjectGroupOption); |
| } |
| }); |
| connectionDomainObjectOption = addSelectTypeOption(KEY_CONNECTION_DOMAIN_OBJECT_CLASS_NAME, |
| Messages.GraphitiEditorTemplateSection_fieldNameConnectionDomainObject, null, 1, |
| connectionDomainObjectGroupOption); |
| connectionDomainObjectOption.setRequired(false); |
| } |
| |
| private GroupOption addGroupOption(int pageIndex, String label) { |
| GroupOption option = new GroupOption(this, label); |
| registerOption(option, "", pageIndex); //$NON-NLS-1$ |
| return option; |
| } |
| |
| private TemplateOption addGroupedOption(String name, String label, String value, int pageIndex, |
| GroupOption groupOption) { |
| StringOption option = new GroupableStringOption(this, name, label, groupOption); |
| registerOption(option, value, pageIndex); |
| return option; |
| } |
| |
| private GroupableBooleanOption addGroupedOption(String name, String label, boolean value, int pageIndex, |
| GroupOption groupOption, SelectionListener listener) { |
| GroupableBooleanOption option = new GroupableBooleanOption(this, name, label, groupOption, listener); |
| registerOption(option, value, pageIndex); |
| return option; |
| } |
| |
| private SelectTypeOption addSelectTypeOption(String name, String label, String value, int pageIndex, |
| GroupOption groupOption) { |
| SelectTypeOption option = new SelectTypeOption(this, name, label, groupOption); |
| registerOption(option, value, pageIndex); |
| return option; |
| } |
| |
| @Override |
| public boolean isDependentOnParentWizard() { |
| // Return true to indicate that the data collection in previous steps of |
| // the wizard (like plugin id and name) need to be propagated to the |
| // initializyFields methods in this instance |
| return true; |
| } |
| |
| @Override |
| protected void initializeFields(IFieldData data) { |
| initializeFields(data.getId(), data.getName()); |
| if (data instanceof IPluginFieldData) { |
| initializeOption(KEY_GENERATE_ACTIVATOR, ((IPluginFieldData) data).doGenerateClass()); |
| } |
| } |
| |
| @Override |
| public void initializeFields(IPluginModelBase model) { |
| super.initializeFields(model); |
| initializeFields(model.getPluginBase().getId(), model.getPluginBase().getName()); |
| } |
| |
| private void initializeFields(String pluginId, String pluginName) { |
| // Get the root package name |
| String rootPackageName = getFormattedPackageName(pluginId); |
| initializeOption(KEY_PACKAGE_NAME, rootPackageName); |
| |
| // Create a prefix |
| String prefix; |
| int lastDot = pluginId.lastIndexOf('.'); |
| if (lastDot != -1) { |
| prefix = pluginId.substring(lastDot + 1); |
| } else { |
| prefix = pluginId; |
| } |
| |
| // Diagram type |
| initializeOption(KEY_DT_ID, pluginId + "." + prefix + "DiagramType"); //$NON-NLS-1$ //$NON-NLS-2$ |
| initializeOption(KEY_DT_NAME, pluginName + " Diagram Type"); //$NON-NLS-1$ |
| initializeOption(KEY_DT_TYPE, prefix); |
| |
| // Diagram type provider |
| initializeOption(KEY_DTP_ID, pluginId + "." + prefix + "DiagramTypeProvider"); //$NON-NLS-1$ //$NON-NLS-2$ |
| initializeOption(KEY_DTP_NAME, pluginName + " Diagram Type Provider"); //$NON-NLS-1$ |
| String classNamePrefix = prefix.substring(0, 1).toUpperCase(Locale.ENGLISH) + prefix.substring(1); |
| initializeOption(KEY_DTP_CLASS_NAME, classNamePrefix + "DiagramTypeProvider"); //$NON-NLS-1$ |
| |
| // Feature provider |
| initializeOption(KEY_FEATURE_PROVIDER_CLASS_NAME, classNamePrefix + "FeatureProvider"); //$NON-NLS-1$ |
| |
| // Shape domain object |
| initializeOption(KEY_USE_SHAPE_DOMAIN_OBJECT, false); |
| initializeOption(KEY_SHAPE_DOMAIN_OBJECT_CLASS_NAME, ""); //$NON-NLS-1$ |
| |
| // Connection domain object |
| initializeOption(KEY_USE_CONNECTION_DOMAIN_OBJECT, false); |
| initializeOption(KEY_CONNECTION_DOMAIN_OBJECT_CLASS_NAME, ""); //$NON-NLS-1$ |
| } |
| |
| private String getFormattedPackageName(String name) { |
| StringBuffer buffer = new StringBuffer(); |
| for (int i = 0; i < name.length(); i++) { |
| char ch = name.charAt(i); |
| if (buffer.length() == 0) { |
| if (Character.isJavaIdentifierStart(ch)) |
| buffer.append(Character.toLowerCase(ch)); |
| } else { |
| if (Character.isJavaIdentifierPart(ch) || ch == '.') |
| buffer.append(ch); |
| } |
| } |
| return buffer.toString().toLowerCase(Locale.ENGLISH); |
| } |
| |
| @Override |
| public void addPages(Wizard wizard) { |
| WizardPage page = createPage(0); |
| page.setTitle(Messages.GraphitiEditorTemplateSection_pageName); |
| page.setDescription(Messages.GraphitiEditorTemplateSection_pageDescription); |
| wizard.addPage(page); |
| |
| page = createPage(1); |
| page.setTitle(Messages.GraphitiEditorTemplateSection_pageTitleDomainObjects); |
| page.setDescription(Messages.GraphitiEditorTemplateSection_pageDescriptionDomainObjects); |
| wizard.addPage(page); |
| |
| markPagesAdded(); |
| } |
| |
| @Override |
| public IPluginReference[] getDependencies(String schemaVersion) { |
| ArrayList<IPluginReference> result = new ArrayList<IPluginReference>(); |
| |
| IPluginReference[] superDependencies = super.getDependencies(schemaVersion); |
| for (IPluginReference dependency : superDependencies) { |
| if ("org.eclipse.ui".equals(dependency.getId())) { //$NON-NLS-1$ |
| if (!getBooleanOption(KEY_GENERATE_ACTIVATOR)) { |
| /* |
| * Skip dependency to og.eclipse.ui, because no activator |
| * shall be created and we don't need this dependency for |
| * anything else; in contrary it is harmful if one tries to |
| * create an e4 RCP app, see |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=388211 |
| */ |
| continue; |
| } |
| } |
| result.add(dependency); |
| } |
| |
| result.add(new PluginReference("org.eclipse.graphiti", null, 0)); //$NON-NLS-1$ |
| result.add(new PluginReference("org.eclipse.graphiti.ui", null, 0)); //$NON-NLS-1$ |
| if (Boolean.TRUE.equals(getValue(KEY_USE_PATTERNS))) { |
| result.add(new PluginReference("org.eclipse.graphiti.pattern", null, 0)); //$NON-NLS-1$ |
| } |
| |
| // Add additional references defined on page 2 of the wizard (domain |
| // dependency) |
| if (Boolean.TRUE.equals(getValue(KEY_USE_SHAPE_DOMAIN_OBJECT))) { |
| String bundleName = shapeDomainObjectOption.getBundleName(); |
| result.add(new PluginReference(bundleName, null, 0)); |
| } |
| if (Boolean.TRUE.equals(getValue(KEY_USE_CONNECTION_DOMAIN_OBJECT))) { |
| String bundleName = connectionDomainObjectOption.getBundleName(); |
| PluginReference reference = new PluginReference(bundleName, null, 0); |
| if (!result.contains(reference)) { |
| result.add(reference); |
| } |
| } |
| |
| return (IPluginReference[]) result.toArray(new IPluginReference[result.size()]); |
| } |
| |
| @Override |
| protected URL getInstallURL() { |
| return Activator.getDefault().getBundle().getEntry("/"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| public String getSectionId() { |
| if ((Boolean) getValue(KEY_USE_PATTERNS)) { |
| return "patterns"; //$NON-NLS-1$ |
| } else { |
| return "features"; //$NON-NLS-1$ |
| } |
| } |
| |
| public String getUsedExtensionPoint() { |
| return "org.eclipse.graphiti"; //$NON-NLS-1$ |
| } |
| |
| public String[] getNewFiles() { |
| return new String[] {}; |
| } |
| |
| @Override |
| protected ResourceBundle getPluginResourceBundle() { |
| return null; |
| } |
| |
| @Override |
| protected void updateModel(IProgressMonitor monitor) throws CoreException { |
| IPluginBase plugin = model.getPluginBase(); |
| IPluginModelFactory factory = model.getPluginFactory(); |
| |
| // Diagram type |
| { |
| IPluginExtension extension = createExtension("org.eclipse.graphiti.ui.diagramTypes", true); //$NON-NLS-1$ |
| |
| IPluginElement element = factory.createElement(extension); |
| element.setName("diagramType"); //$NON-NLS-1$ |
| element.setAttribute("id", getStringOption(KEY_DT_ID)); //$NON-NLS-1$ |
| element.setAttribute("name", getStringOption(KEY_DT_NAME)); //$NON-NLS-1$ |
| element.setAttribute("type", getStringOption(KEY_DT_TYPE)); //$NON-NLS-1$ |
| String description = getStringOption(KEY_DT_DESCRIPTION); |
| if (description != null && description.length() > 0) { |
| element.setAttribute("description", description); //$NON-NLS-1$ |
| } |
| |
| extension.add(element); |
| plugin.add(extension); |
| } |
| |
| // Diagram type provider |
| { |
| IPluginExtension extension = createExtension("org.eclipse.graphiti.ui.diagramTypeProviders", true); //$NON-NLS-1$ |
| |
| IPluginElement element = factory.createElement(extension); |
| element.setName("diagramTypeProvider"); //$NON-NLS-1$ |
| element.setAttribute("id", getStringOption(KEY_DTP_ID)); //$NON-NLS-1$ |
| element.setAttribute("name", getStringOption(KEY_DTP_NAME)); //$NON-NLS-1$ |
| String description = getStringOption(KEY_DTP_DESCRIPTION); |
| if (description != null && description.length() > 0) { |
| element.setAttribute("description", description); //$NON-NLS-1$ |
| } |
| |
| String fullClassName = getStringOption(KEY_PACKAGE_NAME) + ".diagram." //$NON-NLS-1$ |
| + getStringOption(KEY_DTP_CLASS_NAME); |
| element.setAttribute("class", fullClassName); //$NON-NLS-1$ |
| |
| IPluginElement diagramTypeElement = factory.createElement(element); |
| diagramTypeElement.setName("diagramType"); //$NON-NLS-1$ |
| diagramTypeElement.setAttribute("id", getStringOption(KEY_DT_ID)); //$NON-NLS-1$ |
| element.add(diagramTypeElement); |
| |
| extension.add(element); |
| plugin.add(extension); |
| } |
| } |
| |
| @Override |
| public String getReplacementString(String fileName, String key) { |
| if (KEY_SHAPE_DOMAIN_OBJECT_CLASS_NAME_SHORT.equals(key)) { |
| String value = super.getReplacementString(fileName, KEY_SHAPE_DOMAIN_OBJECT_CLASS_NAME); |
| if (value != null && value.length() > 0) { |
| // Domain object name was given -> get last segment |
| int lastIndexOfDot = value.lastIndexOf("."); //$NON-NLS-1$ |
| value = value.substring(lastIndexOfDot + 1); |
| } else { |
| // No domain object given -> use generic name |
| value = "DomainObject"; //$NON-NLS-1$ |
| } |
| return value; |
| } else if (KEY_CONNECTION_DOMAIN_OBJECT_CLASS_NAME_SHORT.equals(key)) { |
| String value = super.getReplacementString(fileName, KEY_CONNECTION_DOMAIN_OBJECT_CLASS_NAME); |
| if (value != null && value.length() > 0) { |
| // Domain object name was given -> get last segment |
| int lastIndexOfDot = value.lastIndexOf("."); //$NON-NLS-1$ |
| value = value.substring(lastIndexOfDot + 1); |
| } else { |
| // No domain object given -> use generic name |
| value = "DomainObjectConnection"; //$NON-NLS-1$ |
| } |
| return value; |
| } else { |
| return super.getReplacementString(fileName, key); |
| } |
| } |
| |
| @Override |
| public void validateOptions(TemplateOption source) { |
| /* |
| * Workaround for super class only checking page one. reimplement here |
| * and check all pages |
| */ |
| |
| // Check template source itself |
| if (source.isRequired() && source.isEmpty()) { |
| flagMissingRequiredOption(source); |
| } |
| |
| // Check first page |
| TemplateOption[] allPageOptions = getOptions(0); |
| for (int i = 0; i < allPageOptions.length; i++) { |
| TemplateOption nextOption = allPageOptions[i]; |
| if (nextOption.isRequired() && nextOption.isEmpty()) { |
| flagMissingRequiredOption(nextOption); |
| return; |
| } |
| } |
| resetPageState(); |
| |
| // Check second page |
| allPageOptions = getOptions(1); |
| for (int i = 0; i < allPageOptions.length; i++) { |
| TemplateOption nextOption = allPageOptions[i]; |
| if (nextOption.isRequired() && nextOption.isEmpty()) { |
| flagMissingRequiredOption(nextOption); |
| return; |
| } |
| } |
| resetPageState(); |
| } |
| } |