| /******************************************************************************* |
| * Copyright (c) 2011, 2012 Red Hat, Inc. |
| * All rights reserved. |
| * This program is 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: |
| * Red Hat, Inc. - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.bpmn2.modeler.ui.property.diagrams; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.bpmn2.Bpmn2Package; |
| import org.eclipse.bpmn2.DocumentRoot; |
| import org.eclipse.bpmn2.EndPoint; |
| import org.eclipse.bpmn2.Import; |
| import org.eclipse.bpmn2.impl.DefinitionsImpl; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.AbstractBpmn2PropertySection; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.AbstractDetailComposite; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.AbstractListComposite; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.AbstractPropertiesProvider; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.DefaultDetailComposite; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.DefaultListComposite; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.ListCompositeColumnProvider; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.ListCompositeContentProvider; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.PropertiesCompositeFactory; |
| import org.eclipse.bpmn2.modeler.core.merrimac.clad.TableColumn; |
| import org.eclipse.bpmn2.modeler.core.merrimac.dialogs.ObjectEditor; |
| import org.eclipse.bpmn2.modeler.core.merrimac.dialogs.TextAndButtonObjectEditor; |
| import org.eclipse.bpmn2.modeler.core.merrimac.dialogs.TextObjectEditor; |
| import org.eclipse.bpmn2.modeler.core.runtime.ModelExtensionDescriptor; |
| import org.eclipse.bpmn2.modeler.core.runtime.ModelExtensionDescriptor.Property; |
| import org.eclipse.bpmn2.modeler.core.runtime.TargetRuntime; |
| import org.eclipse.bpmn2.modeler.core.utils.ImportUtil; |
| import org.eclipse.bpmn2.modeler.core.utils.ModelUtil; |
| import org.eclipse.bpmn2.modeler.core.utils.NamespaceUtil; |
| import org.eclipse.bpmn2.modeler.ui.property.dialogs.NamespacesEditingDialog; |
| import org.eclipse.bpmn2.modeler.ui.property.dialogs.SchemaImportDialog; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.util.EcoreEMap; |
| import org.eclipse.emf.transaction.RecordingCommand; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.viewers.CellEditor; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.Composite; |
| |
| public class DefinitionsPropertyComposite extends DefaultDetailComposite { |
| |
| public DefinitionsPropertyComposite(Composite parent, int style) { |
| super(parent, style); |
| } |
| |
| private NamespaceListComposite namespacesTable; |
| |
| /** |
| * @param section |
| */ |
| public DefinitionsPropertyComposite(AbstractBpmn2PropertySection section) { |
| super(section); |
| } |
| |
| @Override |
| public AbstractPropertiesProvider getPropertiesProvider(EObject object) { |
| if (propertiesProvider==null) { |
| propertiesProvider = new AbstractPropertiesProvider(object) { |
| String[] properties = new String[] { |
| "name", //$NON-NLS-1$ |
| "targetNamespace", //$NON-NLS-1$ |
| "typeLanguage", //$NON-NLS-1$ |
| "expressionLanguage", //$NON-NLS-1$ |
| "exporter", //$NON-NLS-1$ |
| "exporterVersion", //$NON-NLS-1$ |
| "imports", //$NON-NLS-1$ |
| "namespaces", //$NON-NLS-1$ |
| "rootElements#ItemDefinition", //$NON-NLS-1$ |
| "relationships", //$NON-NLS-1$ |
| "rootElements#PartnerEntity", //$NON-NLS-1$ |
| "rootElements#PartnerRole", //$NON-NLS-1$ |
| // "rootElements#EndPoint", //$NON-NLS-1$ |
| "rootElements#Resource", //$NON-NLS-1$ |
| "rootElements#DataStore", //$NON-NLS-1$ |
| "rootElements#Message", //$NON-NLS-1$ |
| "rootElements#Error", //$NON-NLS-1$ |
| "rootElements#Escalation", //$NON-NLS-1$ |
| "rootElements#Signal", //$NON-NLS-1$ |
| "rootElements#CorrelationProperty", //$NON-NLS-1$ |
| "rootElements#Category", //$NON-NLS-1$ |
| }; |
| |
| @Override |
| public String[] getProperties() { |
| return properties; |
| } |
| }; |
| } |
| return propertiesProvider; |
| } |
| |
| @Override |
| public void cleanBindings() { |
| super.cleanBindings(); |
| namespacesTable = null; |
| } |
| |
| @Override |
| protected Composite bindProperty(EObject be, String property) { |
| if ("namespaces".equals(property)) { |
| namespacesTable = new NamespaceListComposite(getPropertySection()); |
| DefinitionsImpl definitions = (DefinitionsImpl)getBusinessObject(); |
| DocumentRoot root = (DocumentRoot) definitions.eContainer(); |
| namespacesTable.bindList(root, Bpmn2Package.eINSTANCE.getDocumentRoot_XMLNSPrefixMap()); |
| namespacesTable.setTitle("Namespaces"); //$NON-NLS-1$ |
| return namespacesTable; |
| } |
| return super.bindProperty(be, property); |
| } |
| |
| @Override |
| protected AbstractListComposite bindList(EObject object, EStructuralFeature feature, EClass listItemClass) { |
| if ("imports".equals(feature.getName())) { //$NON-NLS-1$ |
| ImportListComposite importsTable = new ImportListComposite(getPropertySection()); |
| EStructuralFeature importsFeature = object.eClass().getEStructuralFeature("imports"); //$NON-NLS-1$ |
| importsTable.bindList(object, importsFeature); |
| return importsTable; |
| } |
| else if ("relationships".equals(feature.getName())) { //$NON-NLS-1$ |
| DefaultListComposite table = new DefaultListComposite(getPropertySection()); |
| table.bindList(getBusinessObject(), feature); |
| return table; |
| } |
| else if (listItemClass!=null && listItemClass.getName().equals("EndPoint")) { |
| EndPointListComposite table = new EndPointListComposite(getPropertySection()); |
| table.bindList(getBusinessObject(), feature); |
| return table; |
| } |
| else { |
| return super.bindList(object, feature, listItemClass); |
| } |
| } |
| |
| public class NamespaceListComposite extends DefaultListComposite { |
| |
| public NamespaceListComposite(AbstractBpmn2PropertySection section) { |
| super(section, ADD_BUTTON | REMOVE_BUTTON | EDIT_BUTTON); |
| } |
| |
| |
| @Override |
| protected EObject addListItem(EObject object, EStructuralFeature feature) { |
| DocumentRoot root = (DocumentRoot)object; |
| Map<String,String> map = root.getXMLNSPrefixMap(); |
| NamespacesEditingDialog dialog = new NamespacesEditingDialog(getShell(), |
| Messages.DefinitionsPropertyComposite_Create_Namespace_Title, map, "",""); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (dialog.open() == Window.OK) { |
| map.put(dialog.getPrefix(), dialog.getNamespace()); |
| } |
| return null; |
| } |
| |
| @Override |
| protected Object removeListItem(EObject object, EStructuralFeature feature, int index) { |
| DocumentRoot root = (DocumentRoot)object; |
| Map<String,String> map = root.getXMLNSPrefixMap(); |
| for ( Map.Entry<String, String> entry : map.entrySet() ) { |
| if (index-- == 0) { |
| map.remove( entry.getKey() ); |
| break; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public AbstractDetailComposite createDetailComposite(Class eClass, final Composite parent, int style) { |
| detailSection.setText(Messages.DefinitionsPropertyComposite_Namespace_Details_Title); |
| AbstractDetailComposite composite = new DefaultDetailComposite(parent, SWT.NONE) { |
| |
| @Override |
| protected void bindAttribute(Composite parent, EObject object, EAttribute attribute, String label) { |
| if (attribute.getName().equals("key")) { //$NON-NLS-1$ |
| ObjectEditor editor = new TextAndButtonObjectEditor(this,businessObject,attribute) { |
| |
| @Override |
| protected void buttonClicked(int buttonId) { |
| Map.Entry<String, String> entry = (Map.Entry<String, String>)object; |
| DocumentRoot root = (DocumentRoot)object.eContainer(); |
| Map<String, String> map = (Map<String, String>)root.getXMLNSPrefixMap(); |
| NamespacesEditingDialog dialog = new NamespacesEditingDialog(getShell(), Messages.DefinitionsPropertyComposite_Change_Namespace_Title, map, entry.getKey(),null); |
| if (dialog.open() == Window.OK) { |
| setValue(dialog.getPrefix()); |
| } |
| } |
| |
| @Override |
| protected boolean setValue(final Object result) { |
| // we can't just change the key because the map that contains it |
| // needs to be updated, so remove old key, then add new. |
| if (result instanceof String && !((String)result).isEmpty() ) { |
| final Map.Entry<String, String> entry = (Map.Entry<String, String>)object; |
| final String oldKey = entry.getKey(); |
| TransactionalEditingDomain domain = getDiagramEditor().getEditingDomain(); |
| domain.getCommandStack().execute(new RecordingCommand(domain) { |
| @Override |
| protected void doExecute() { |
| DocumentRoot root = (DocumentRoot)object.eContainer(); |
| Map<String, String> map = (Map<String, String>)root.getXMLNSPrefixMap(); |
| String value = map.remove(oldKey); |
| map.put((String)result, value); |
| } |
| }); |
| return true; |
| } |
| text.setText(ModelUtil.getDisplayName(object, feature)); |
| return false; |
| } |
| }; |
| editor.createControl(parent,"Prefix"); //$NON-NLS-1$ |
| } |
| else { |
| ObjectEditor editor = new TextObjectEditor(this,businessObject,attribute); |
| editor.createControl(parent,Messages.DefinitionsPropertyComposite_Namespace_Label); |
| } |
| } |
| }; |
| return composite; |
| } |
| |
| @Override |
| public ListCompositeContentProvider getContentProvider(EObject object, EStructuralFeature feature, EList<EObject>list) { |
| if (contentProvider==null) { |
| contentProvider = new ListCompositeContentProvider(this, object, feature, list) { |
| |
| @Override |
| public Object[] getElements(Object inputElement) { |
| List<Object> elements = new ArrayList<Object>(); |
| EcoreEMap<String,String> map = (EcoreEMap<String,String>)inputElement; |
| for ( Map.Entry<String, String> entry : map.entrySet() ) { |
| elements.add(entry); |
| } |
| return elements.toArray(new EObject[elements.size()]); |
| } |
| |
| }; |
| } |
| return contentProvider; |
| } |
| |
| @Override |
| protected int createColumnProvider(EObject theobject, EStructuralFeature thefeature) { |
| if (columnProvider==null) { |
| columnProvider = getColumnProvider(theobject, thefeature); |
| } |
| return columnProvider.getColumns().size(); |
| } |
| |
| @Override |
| public ListCompositeColumnProvider getColumnProvider(EObject object, EStructuralFeature feature) { |
| if (columnProvider==null) { |
| columnProvider = new ListCompositeColumnProvider(this); |
| columnProvider.addRaw(new NamespacesTableColumn(object, 0)); |
| columnProvider.addRaw(new NamespacesTableColumn(object, 1)); |
| } |
| return columnProvider; |
| } |
| |
| public class NamespacesTableColumn extends TableColumn { |
| |
| int columnIndex; |
| |
| public NamespacesTableColumn(EObject object, int columnIndex) { |
| super(object,(EStructuralFeature)null); |
| this.columnIndex = columnIndex; |
| } |
| |
| @Override |
| public String getProperty() { |
| return getHeaderText(); |
| } |
| |
| @Override |
| public String getHeaderText() { |
| if (columnIndex==0) |
| return Messages.DefinitionsPropertyComposite_Prefix_Label; |
| return Messages.DefinitionsPropertyComposite_Namespace_Label; |
| } |
| |
| @Override |
| public String getText(Object element) { |
| Map.Entry<String, String> entry = (Map.Entry<String, String>)element; |
| if (columnIndex==0) |
| return entry.getKey(); |
| return entry.getValue(); |
| } |
| } |
| } |
| |
| public class ImportListComposite extends DefaultListComposite { |
| |
| /** |
| * @param parent |
| * @param style |
| */ |
| public ImportListComposite(AbstractBpmn2PropertySection section) { |
| super(section); |
| } |
| |
| @Override |
| public ListCompositeColumnProvider getColumnProvider(EObject object, EStructuralFeature feature) { |
| if (columnProvider==null) { |
| columnProvider = new ListCompositeColumnProvider(this); |
| |
| // add a namespace prefix column that does NOT come from the Import object |
| TableColumn tableColumn = new TableColumn(object,(EStructuralFeature)null) { |
| @Override |
| public String getHeaderText() { |
| return Messages.DefinitionsPropertyComposite_Prefix_Label; |
| } |
| |
| @Override |
| public String getText(Object element) { |
| Import imp = (Import)element; |
| String prefix = NamespaceUtil.getPrefixForNamespace(imp.eResource(), imp.getNamespace()); |
| if (prefix!=null) |
| return prefix; |
| return ""; //$NON-NLS-1$ |
| } |
| |
| @Override |
| public CellEditor createCellEditor (Composite parent) { |
| CellEditor ce = null; |
| // TODO: create a dialog cell editor for NS prefix |
| return ce; |
| } |
| }; |
| columnProvider.add(tableColumn); |
| // add remaining columns |
| columnProvider.add(new TableColumn(object,PACKAGE.getImport_Namespace())).setEditable(false); |
| columnProvider.add(new TableColumn(object,PACKAGE.getImport_Location())).setEditable(false); |
| columnProvider.add(new TableColumn(object,PACKAGE.getImport_ImportType())).setEditable(false); |
| } |
| return columnProvider; |
| } |
| |
| |
| @Override |
| protected EObject editListItem(EObject object, EStructuralFeature feature) { |
| return super.editListItem(object, feature); |
| } |
| |
| |
| @Override |
| protected Object removeListItem(EObject object, EStructuralFeature feature, int index) { |
| EList<Import> list = (EList<Import>)object.eGet(feature); |
| Import imp = list.get(index); |
| ImportUtil.removeImport(imp); |
| // return super.removeListItem(object, feature, index); |
| return null; |
| } |
| |
| @Override |
| protected EObject addListItem(EObject object, EStructuralFeature feature) { |
| SchemaImportDialog dialog = new SchemaImportDialog(getShell()); |
| if (dialog.open() == Window.OK) { |
| Object result[] = dialog.getResult(); |
| if (result.length == 1) { |
| ImportUtil importer = new ImportUtil(); |
| return importer.addImport(object, result[0]); |
| } |
| } |
| return null; |
| } |
| } |
| |
| public class ImportDetailComposite extends DefaultDetailComposite { |
| |
| public ImportDetailComposite(Composite parent, int style) { |
| super(parent, style); |
| } |
| |
| /** |
| * @param section |
| */ |
| public ImportDetailComposite(AbstractBpmn2PropertySection section) { |
| super(section); |
| } |
| |
| @Override |
| public void createBindings(EObject be) { |
| final Import imp = (Import)be; |
| |
| Composite composite = getAttributesParent(); |
| TextObjectEditor editor; |
| String label; |
| EStructuralFeature feature; |
| |
| feature = null; |
| label = Messages.DefinitionsPropertyComposite_Prefix_Label; |
| editor = new TextAndButtonObjectEditor(this,be,feature) { |
| |
| @Override |
| protected void buttonClicked(int buttonId) { |
| IInputValidator validator = new IInputValidator() { |
| |
| @Override |
| public String isValid(String newText) { |
| String ns = NamespaceUtil.getNamespaceForPrefix(imp.eResource(), newText); |
| if (ns==null) |
| return null; |
| return NLS.bind( |
| Messages.DefinitionsPropertyComposite_Invalid_Duplicate, |
| newText,ns); |
| } |
| |
| }; |
| String initialValue = getText(); |
| InputDialog dialog = new InputDialog( |
| getShell(), |
| Messages.DefinitionsPropertyComposite_Prefix_Label, |
| Messages.DefinitionsPropertyComposite_Prefix_Message, |
| initialValue, |
| validator); |
| if (dialog.open()==Window.OK){ |
| setValue(dialog.getValue()); |
| } |
| } |
| |
| protected boolean setValue(final Object value) { |
| // remove old prefix |
| String prefix = text.getText(); |
| NamespaceUtil.removeNamespaceForPrefix(imp.eResource(), prefix); |
| // and add new |
| NamespaceUtil.addNamespace(imp.eResource(), (String)value, imp.getNamespace()); |
| setText((String) value); |
| return true; |
| } |
| |
| protected String getText() { |
| return getNamespacePrefix(); |
| } |
| }; |
| editor.createControl(composite,label); |
| |
| feature = Bpmn2Package.eINSTANCE.getImport_Namespace(); |
| label = ModelUtil.getLabel(be, feature); |
| editor = new TextObjectEditor(this,be, feature); |
| editor.createControl(composite,label); |
| editor.setEditable(false); |
| |
| feature = Bpmn2Package.eINSTANCE.getImport_Location(); |
| label = ModelUtil.getLabel(be, feature); |
| editor = new TextObjectEditor(this,be, feature); |
| editor.createControl(composite,label); |
| editor.setEditable(false); |
| |
| feature = Bpmn2Package.eINSTANCE.getImport_ImportType(); |
| label = ModelUtil.getLabel(be, feature); |
| editor = new TextObjectEditor(this,be, feature); |
| editor.createControl(composite,label); |
| editor.setEditable(false); |
| } |
| |
| private String getNamespacePrefix() { |
| Import imp = (Import)businessObject; |
| String prefix = NamespaceUtil.getPrefixForNamespace(imp.eResource(), imp.getNamespace()); |
| if (prefix==null) |
| prefix = ""; //$NON-NLS-1$ |
| return prefix; |
| } |
| } |
| |
| public class EndPointListComposite extends DefaultListComposite { |
| |
| public EndPointListComposite(AbstractBpmn2PropertySection section) { |
| super(section); |
| } |
| |
| @Override |
| public EClass getListItemClass(EObject object, EStructuralFeature feature) { |
| return Bpmn2Package.eINSTANCE.getEndPoint(); |
| } |
| |
| // protected int createColumnProvider(EObject object, EStructuralFeature feature) { |
| // if (columnProvider==null) { |
| // columnProvider = new ListCompositeColumnProvider(this); |
| // |
| // TargetRuntime rt = getTargetRuntime(); |
| // for (ModelExtensionDescriptor md : rt.getModelExtensions()) { |
| // if ("EndPoint".equals(md.getType())) { |
| // |
| // for (Property p : md.getProperties()) { |
| // final String name = p.name; |
| // TableColumn tableColumn = new TableColumn(object,(EStructuralFeature)null) { |
| // @Override |
| // public String getHeaderText() { |
| // return ModelUtil.toDisplayName(name); |
| // } |
| // |
| // @Override |
| // public String getText(Object element) { |
| // if (element instanceof EndPoint) { |
| // EndPoint ep = (EndPoint) element; |
| // EStructuralFeature feature = ModelUtil.getAnyAttribute(ep, name); |
| // Object v = ep.eGet(feature); |
| // if (v!=null) |
| // return v.toString(); |
| // } |
| // return ""; //$NON-NLS-1$ |
| // } |
| // |
| // @Override |
| // public CellEditor createCellEditor (Composite parent) { |
| // CellEditor ce = null; |
| // return ce; |
| // } |
| // }; |
| // columnProvider.add(tableColumn); |
| // } |
| // } |
| // } |
| // } |
| // return columnProvider.getColumns().size(); |
| // } |
| // |
| // @Override |
| // public AbstractDetailComposite createDetailComposite(Class eClass, Composite parent, int style) { |
| // AbstractDetailComposite composite = new DefaultDetailComposite(parent, style) { |
| // |
| // protected boolean isModelObjectEnabled(EClass eclass, EStructuralFeature feature) { |
| // return true; |
| // } |
| // |
| // @Override |
| // public AbstractPropertiesProvider getPropertiesProvider(EObject object) { |
| // if (propertiesProvider==null) { |
| // propertiesProvider = new AbstractPropertiesProvider(object) { |
| // String[] properties = null; |
| // |
| // @Override |
| // public String[] getProperties() { |
| // if (properties==null) { |
| // TargetRuntime rt = getTargetRuntime(); |
| // for (ModelExtensionDescriptor md : rt.getModelExtensions()) { |
| // if ("EndPoint".equals(md.getType())) { |
| // properties = new String[md.getProperties().size()]; |
| // int i=0; |
| // for (Property p : md.getProperties()) { |
| // properties[i++] = p.name; |
| // } |
| // } |
| // } |
| // } |
| // |
| // return properties; |
| // } |
| // }; |
| // } |
| // return propertiesProvider; |
| // } |
| // |
| // }; |
| // |
| // return composite; |
| // } |
| |
| @Override |
| protected EObject addListItem(EObject object, EStructuralFeature feature) { |
| EObject ep = super.addListItem(object, feature); |
| // TargetRuntime rt = getTargetRuntime(); |
| // for (ModelExtensionDescriptor md : rt.getModelExtensions()) { |
| // if ("EndPoint".equals(md.getType())) { |
| // md.populateObject(ep, true); |
| // } |
| // } |
| |
| return ep; |
| } |
| } |
| } |
