| /******************************************************************************* |
| * Copyright (c) 2007, 2012 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.bpel.ui.properties; |
| |
| import java.util.Collections; |
| import java.util.List; |
| |
| import org.eclipse.bpel.common.ui.assist.FieldAssistAdapter; |
| import org.eclipse.bpel.common.ui.details.IDetailsAreaConstants; |
| import org.eclipse.bpel.common.ui.details.IOngoingChange; |
| import org.eclipse.bpel.common.ui.flatui.FlatFormAttachment; |
| import org.eclipse.bpel.common.ui.flatui.FlatFormData; |
| import org.eclipse.bpel.common.ui.flatui.FlatFormLayout; |
| import org.eclipse.bpel.model.BPELFactory; |
| import org.eclipse.bpel.model.FromPart; |
| import org.eclipse.bpel.model.FromParts; |
| import org.eclipse.bpel.model.Invoke; |
| import org.eclipse.bpel.model.OnEvent; |
| import org.eclipse.bpel.model.OnMessage; |
| import org.eclipse.bpel.model.Receive; |
| import org.eclipse.bpel.model.Reply; |
| import org.eclipse.bpel.model.ToPart; |
| import org.eclipse.bpel.model.ToParts; |
| import org.eclipse.bpel.model.Variable; |
| import org.eclipse.bpel.model.util.BPELUtils; |
| import org.eclipse.bpel.ui.IBPELUIConstants; |
| import org.eclipse.bpel.ui.Messages; |
| import org.eclipse.bpel.ui.commands.AddFromPartCommand; |
| import org.eclipse.bpel.ui.commands.AddToPartCommand; |
| import org.eclipse.bpel.ui.commands.AddVariableCommand; |
| import org.eclipse.bpel.ui.commands.CompoundCommand; |
| import org.eclipse.bpel.ui.commands.SetVariableCommand; |
| import org.eclipse.bpel.ui.commands.util.AutoUndoCommand; |
| import org.eclipse.bpel.ui.details.providers.ModelLabelProvider; |
| import org.eclipse.bpel.ui.details.providers.VariableContentProvider; |
| import org.eclipse.bpel.ui.details.providers.VariableFilter; |
| import org.eclipse.bpel.ui.proposal.providers.ModelContentProposalProvider; |
| import org.eclipse.bpel.ui.proposal.providers.RunnableProposal; |
| import org.eclipse.bpel.ui.proposal.providers.Separator; |
| import org.eclipse.bpel.ui.util.BPELUtil; |
| import org.eclipse.bpel.ui.util.BatchedMultiObjectAdapter; |
| import org.eclipse.bpel.ui.util.ModelHelper; |
| import org.eclipse.bpel.ui.util.MultiObjectAdapter; |
| import org.eclipse.bpel.ui.util.NameDialog; |
| import org.eclipse.bpel.ui.util.PartMappingUtil; |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.gef.commands.Command; |
| import org.eclipse.jface.fieldassist.ContentProposalAdapter; |
| import org.eclipse.jface.fieldassist.IContentProposal; |
| import org.eclipse.jface.fieldassist.IContentProposalListener; |
| import org.eclipse.jface.fieldassist.IControlContentAdapter; |
| import org.eclipse.jface.fieldassist.TextContentAdapter; |
| import org.eclipse.jface.viewers.ILabelProvider; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.CLabel; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.FocusListener; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.swt.widgets.Widget; |
| import org.eclipse.wst.wsdl.Message; |
| import org.eclipse.wst.wsdl.Operation; |
| import org.eclipse.wst.wsdl.Part; |
| import org.eclipse.wst.wsdl.util.WSDLConstants; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| |
| public class InvokeVariableSection extends BPELPropertySection { |
| |
| /** |
| * Selection Listener for the "Use Part Mapping" checkbox |
| */ |
| private class UsePartMappingCheckboxSelectionListener implements |
| SelectionListener { |
| |
| public void widgetDefaultSelected(SelectionEvent e) { |
| } |
| |
| public void widgetSelected(SelectionEvent e) { |
| |
| // Null out the variable/inputVariable/outputVarable fields |
| CompoundCommand ccmd = new CompoundCommand(); |
| if (ModelHelper.isMessageActivity(getModel(), ModelHelper.INCOMING)) { |
| ccmd.add(new SetVariableCommand(getModel(), null, |
| ModelHelper.INCOMING)); |
| } |
| if (ModelHelper.isMessageActivity(getModel(), ModelHelper.OUTGOING)) { |
| ccmd.add(new SetVariableCommand(getModel(), null, |
| ModelHelper.OUTGOING)); |
| } |
| // Null out the fromParts and toParts |
| ccmd.add(new AutoUndoCommand(getInput()) { |
| @Override |
| public void doExecute() { |
| try { |
| ModelHelper.setToParts(getInput(), null); |
| } catch (IllegalArgumentException e) { |
| } |
| try { |
| ModelHelper.setFromParts(getInput(), null); |
| } catch (IllegalArgumentException e) { |
| } |
| } |
| }); |
| |
| getCommandFramework().execute(ccmd); |
| } |
| } |
| |
| private VariableFilter fInputVariableFilter = new VariableFilter(); |
| private VariableFilter fOutputVariableFilter = new VariableFilter(); |
| private IControlContentAdapter fTextContentAdapter = new TextContentAdapter() { |
| @Override |
| public void insertControlContents(Control control, String text, |
| int cursorPosition) { |
| if (text != null) { |
| super.insertControlContents(control, text, cursorPosition); |
| } |
| } |
| |
| @Override |
| public void setControlContents(Control control, String text, |
| int cursorPosition) { |
| if (text != null) { |
| super.setControlContents(control, text, cursorPosition); |
| } |
| } |
| }; |
| private Button inputVariableButton; |
| private Composite inputVariableComposite; |
| private Label inputVariableLabel; |
| private Text inputVariableText; |
| private Composite nonPartMappingComposite; |
| private Widget operationLabel; |
| private Button outputVariableButton; |
| private Composite outputVariableComposite; |
| private Label outputVariableLabel; |
| private Text outputVariableText; |
| private Composite parentComposite; |
| private Composite partMappingComposite; |
| private Button usePartMappingCheckbox; |
| |
| @Override |
| protected void addAllAdapters() { |
| // model object |
| super.addAllAdapters(); |
| |
| // fromParts |
| try { |
| FromParts fromParts = ModelHelper.getFromParts(getModel()); |
| if (fromParts != null) { |
| fAdapters[0].addToObject(fromParts); |
| if (fromParts.getChildren() != null) { |
| // add it to every single fromPart |
| for (FromPart fromPart : fromParts.getChildren()) { |
| fAdapters[0].addToObject(fromPart); |
| } |
| } |
| } |
| } catch (IllegalArgumentException e) { |
| } |
| |
| // toParts |
| try { |
| ToParts toParts = ModelHelper.getToParts(getModel()); |
| if (toParts != null) { |
| fAdapters[0].addToObject(toParts); |
| if (toParts.getChildren() != null) { |
| // add it to every single fromPart |
| for (ToPart toPart : toParts.getChildren()) { |
| fAdapters[0].addToObject(toPart); |
| } |
| } |
| } |
| } catch (IllegalArgumentException e) { |
| } |
| } |
| |
| @Override |
| protected void basicSetInput(EObject newInput) { |
| super.basicSetInput(newInput); |
| |
| this.usePartMappingCheckbox |
| .setSelection(shouldUsePartMapping(getModel())); |
| } |
| |
| @Override |
| protected MultiObjectAdapter[] createAdapters() { |
| return new MultiObjectAdapter[] { |
| /* model object */ |
| new BatchedMultiObjectAdapter() { |
| |
| @Override |
| public void finish() { |
| refresh(); |
| } |
| |
| @Override |
| public void notify(Notification n) { |
| |
| /* |
| * This is a hack to make the QuickPicker work: If a variable is |
| * set to our model object (either by command or by the |
| * QuickPicker) we deselect the checkbox. |
| */ |
| if (ModelHelper.isVariableAffected(getInput(), n, |
| ModelHelper.INCOMING) |
| || ModelHelper.isVariableAffected(getInput(), n, |
| ModelHelper.OUTGOING)) { |
| // something has happened to our variable |
| if (n.getEventType() == Notification.SET |
| && n.getNewValue() != null) { |
| // a new variable has been set |
| usePartMappingCheckbox.setSelection(false); |
| try { |
| ModelHelper.setToParts(getInput(), null); |
| } catch (IllegalArgumentException e) { |
| } |
| try { |
| ModelHelper.setFromParts(getInput(), null); |
| } catch (IllegalArgumentException e) { |
| } |
| } |
| } |
| } |
| |
| } }; |
| } |
| |
| @Override |
| protected void createClient(Composite parent) { |
| |
| Composite composite = createFlatFormComposite(parent); |
| createWidgets(composite); |
| } |
| |
| private Composite createInputVariableWidgets(Composite top, Composite parent) { |
| FlatFormData data; |
| |
| final Composite composite = inputVariableComposite = createFlatFormComposite(parent); |
| data = new FlatFormData(); |
| if (top == null) { |
| data.top = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE); |
| } else { |
| data.top = new FlatFormAttachment(top, IDetailsAreaConstants.VSPACE); |
| } |
| data.left = new FlatFormAttachment(0, IDetailsAreaConstants.HSPACE); |
| data.right = new FlatFormAttachment(InvokeImplSection.SPLIT_POINT, |
| -InvokeImplSection.SPLIT_POINT_OFFSET); |
| composite.setLayoutData(data); |
| |
| inputVariableLabel = fWidgetFactory.createLabel(composite, |
| Messages.InvokeImplSection_7); |
| inputVariableText = fWidgetFactory.createText(composite, EMPTY_STRING); |
| inputVariableButton = fWidgetFactory.createButton(composite, |
| EMPTY_STRING, SWT.ARROW | SWT.DOWN | SWT.CENTER); |
| |
| // Provide Content Assist for the variables |
| // Content assist on partnerName |
| RunnableProposal proposal = new RunnableProposal() { |
| |
| @Override |
| public String getLabel() { |
| return Messages.InvokeImplSection_10; |
| } |
| |
| public void run() { |
| createVariable(BPELUtils.getProcess(getInput()), null, |
| isInvoke() ? ModelHelper.OUTGOING |
| : ModelHelper.INCOMING); |
| } |
| }; |
| |
| RunnableProposal proposal2 = new RunnableProposal() { |
| |
| @Override |
| public String getLabel() { |
| return Messages.InvokeImplSection_11; |
| } |
| |
| public void run() { |
| createVariable(getInput(), null, |
| isInvoke() ? ModelHelper.OUTGOING |
| : ModelHelper.INCOMING); |
| } |
| }; |
| |
| RunnableProposal proposal3 = new RunnableProposal() { |
| @Override |
| public String getLabel() { |
| return Messages.InvokeImplSection_12; |
| } |
| |
| public void run() { |
| int direction = isInvoke() ? ModelHelper.OUTGOING |
| : ModelHelper.INCOMING; |
| getCommandFramework().execute( |
| new SetVariableCommand(getInput(), null, direction)); |
| } |
| }; |
| |
| VariableContentProvider provider = new VariableContentProvider(); |
| ModelContentProposalProvider proposalProvider; |
| proposalProvider = new ModelContentProposalProvider( |
| new ModelContentProposalProvider.ValueProvider() { |
| @Override |
| public Object value() { |
| return getInput(); |
| } |
| }, provider, fInputVariableFilter); |
| |
| proposalProvider.addProposalToEnd(new Separator()); |
| proposalProvider.addProposalToEnd(proposal); |
| proposalProvider.addProposalToEnd(proposal2); |
| proposalProvider.addProposalToEnd(proposal3); |
| |
| final FieldAssistAdapter contentAssist = new FieldAssistAdapter( |
| inputVariableText, fTextContentAdapter, proposalProvider, null, |
| null, true); |
| // |
| contentAssist.setLabelProvider(new ModelLabelProvider()); |
| contentAssist.setPopupSize(new Point(300, 100)); |
| contentAssist.setFilterStyle(ContentProposalAdapter.FILTER_CUMULATIVE); |
| contentAssist |
| .setProposalAcceptanceStyle(ContentProposalAdapter.PROPOSAL_REPLACE); |
| contentAssist.addContentProposalListener(proposal); |
| contentAssist.addContentProposalListener(proposal2); |
| contentAssist.addContentProposalListener(proposal3); |
| contentAssist |
| .addContentProposalListener(new IContentProposalListener() { |
| |
| public void proposalAccepted(IContentProposal chosenProposal) { |
| if (chosenProposal.getContent() == null) { |
| return; |
| } |
| Variable variable = null; |
| try { |
| variable = (Variable) ((Adapter) chosenProposal) |
| .getTarget(); |
| } catch (Throwable t) { |
| return; |
| } |
| SetVariableCommand cmd = new SetVariableCommand( |
| getInput(), variable); |
| getCommandFramework().execute(cmd); |
| } |
| }); |
| |
| // End of Content Assist for variable |
| inputVariableButton.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| contentAssist.openProposals(); |
| } |
| }); |
| |
| inputVariableText.addListener(SWT.KeyDown, new Listener() { |
| public void handleEvent(Event event) { |
| if (event.keyCode == SWT.CR) { |
| findAndSetOrCreateVariable(inputVariableText.getText(), |
| isInvoke() ? ModelHelper.OUTGOING |
| : ModelHelper.INCOMING); |
| } |
| } |
| }); |
| |
| // https://issues.jboss.org/browse/JBIDE-8048 |
| // do the same thing when variable name widget loses focus |
| inputVariableText.addFocusListener(new FocusListener() { |
| |
| public void focusGained(FocusEvent arg0) { |
| } |
| |
| public void focusLost(FocusEvent arg0) { |
| findAndSetOrCreateVariable(inputVariableText.getText(), |
| isInvoke() ? ModelHelper.OUTGOING |
| : ModelHelper.INCOMING); |
| } |
| }); |
| |
| data = new FlatFormData(); |
| data.right = new FlatFormAttachment(100, 0); |
| data.top = new FlatFormAttachment(inputVariableText, +2, SWT.TOP); |
| data.bottom = new FlatFormAttachment(inputVariableText, -2, SWT.BOTTOM); |
| inputVariableButton.setLayoutData(data); |
| |
| data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth( |
| operationLabel, STANDARD_LABEL_WIDTH_SM)); |
| data.right = new FlatFormAttachment(inputVariableButton, 0); |
| inputVariableText.setLayoutData(data); |
| |
| data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, 0); |
| data.right = new FlatFormAttachment(inputVariableText, |
| -IDetailsAreaConstants.HSPACE); |
| data.top = new FlatFormAttachment(inputVariableText, 0, SWT.CENTER); |
| inputVariableLabel.setLayoutData(data); |
| |
| return composite; |
| |
| } |
| |
| /** |
| * The output variable widgets are only pertaining to Invoke activity, if |
| * there is an output message on the partner link |
| * |
| * @param top |
| * @param parent |
| * @return the output variable composite |
| */ |
| |
| private Composite createOutputVariableWidgets(Composite top, |
| Composite parent) { |
| FlatFormData data; |
| |
| final Composite composite = this.outputVariableComposite = createFlatFormComposite(parent); |
| if (isReceive()) { |
| // https://issues.jboss.org/browse/JBIDE-8048 |
| // don't even bother creating widgets we will never use |
| return composite; |
| } |
| |
| data = new FlatFormData(); |
| if (top == null) { |
| data.top = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE); |
| } else { |
| data.top = new FlatFormAttachment(top, IDetailsAreaConstants.VSPACE); |
| } |
| data.left = new FlatFormAttachment(0, IDetailsAreaConstants.HSPACE); |
| data.right = new FlatFormAttachment(InvokeImplSection.SPLIT_POINT, |
| -InvokeImplSection.SPLIT_POINT_OFFSET); |
| composite.setLayoutData(data); |
| |
| outputVariableLabel = fWidgetFactory.createLabel(composite, |
| Messages.InvokeImplSection_13); |
| outputVariableText = fWidgetFactory.createText(composite, EMPTY_STRING); |
| outputVariableButton = fWidgetFactory.createButton(composite, |
| EMPTY_STRING, SWT.ARROW | SWT.DOWN | SWT.CENTER); |
| |
| // Provide Content Assist for the operation |
| |
| // Runnable proposal. |
| RunnableProposal proposal = new RunnableProposal() { |
| |
| @Override |
| public String getLabel() { |
| return Messages.InvokeImplSection_16; |
| } |
| |
| public void run() { |
| createVariable(BPELUtils.getProcess(getInput()), null, |
| isInvoke() ? ModelHelper.INCOMING |
| : ModelHelper.OUTGOING); |
| } |
| }; |
| |
| RunnableProposal proposal2 = new RunnableProposal() { |
| @Override |
| public String getLabel() { |
| return "Create Local Output Variable"; //$NON-NLS-1$ |
| } |
| |
| public void run() { |
| createVariable(getInput(), null, |
| isInvoke() ? ModelHelper.INCOMING |
| : ModelHelper.OUTGOING); |
| } |
| }; |
| |
| RunnableProposal proposal3 = new RunnableProposal() { |
| @Override |
| public String getLabel() { |
| return "Clear Output Variable"; //$NON-NLS-1$ |
| } |
| |
| public void run() { |
| getCommandFramework().execute( |
| new SetVariableCommand(getInput(), null, |
| isInvoke() ? ModelHelper.INCOMING |
| : ModelHelper.OUTGOING)); |
| } |
| }; |
| |
| VariableContentProvider provider = new VariableContentProvider(); |
| ModelContentProposalProvider proposalProvider; |
| proposalProvider = new ModelContentProposalProvider( |
| new ModelContentProposalProvider.ValueProvider() { |
| @Override |
| public Object value() { |
| return getInput(); |
| } |
| }, provider, fOutputVariableFilter); |
| |
| proposalProvider.addProposalToEnd(new Separator()); |
| proposalProvider.addProposalToEnd(proposal); |
| proposalProvider.addProposalToEnd(proposal2); |
| proposalProvider.addProposalToEnd(proposal3); |
| |
| final FieldAssistAdapter contentAssist = new FieldAssistAdapter( |
| outputVariableText, fTextContentAdapter, proposalProvider, |
| null, null, true); |
| // |
| contentAssist.setLabelProvider(new ModelLabelProvider()); |
| contentAssist.setPopupSize(new Point(300, 100)); |
| contentAssist.setFilterStyle(ContentProposalAdapter.FILTER_CUMULATIVE); |
| contentAssist |
| .setProposalAcceptanceStyle(ContentProposalAdapter.PROPOSAL_REPLACE); |
| contentAssist.addContentProposalListener(proposal); |
| contentAssist.addContentProposalListener(proposal2); |
| contentAssist.addContentProposalListener(proposal3); |
| contentAssist |
| .addContentProposalListener(new IContentProposalListener() { |
| |
| public void proposalAccepted(IContentProposal chosenProposal) { |
| if (chosenProposal.getContent() == null) { |
| return; |
| } |
| Variable variable = null; |
| try { |
| variable = (Variable) ((Adapter) chosenProposal) |
| .getTarget(); |
| } catch (Throwable t) { |
| return; |
| } |
| SetVariableCommand cmd = new SetVariableCommand( |
| getInput(), variable, ModelHelper.INCOMING); |
| getCommandFramework().execute(cmd); |
| } |
| }); |
| |
| // End of Content Assist for operation |
| |
| outputVariableButton.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| contentAssist.openProposals(); |
| } |
| }); |
| outputVariableText.addListener(SWT.KeyDown, new Listener() { |
| public void handleEvent(Event event) { |
| if (event.keyCode == SWT.CR) { |
| findAndSetOrCreateVariable(outputVariableText.getText(), |
| ModelHelper.INCOMING); |
| } |
| } |
| }); |
| |
| data = new FlatFormData(); |
| data.right = new FlatFormAttachment(100, 0); |
| data.top = new FlatFormAttachment(outputVariableText, +2, SWT.TOP); |
| data.bottom = new FlatFormAttachment(outputVariableText, -2, SWT.BOTTOM); |
| outputVariableButton.setLayoutData(data); |
| |
| data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth( |
| operationLabel, STANDARD_LABEL_WIDTH_SM)); |
| data.right = new FlatFormAttachment(outputVariableButton, 0); |
| outputVariableText.setLayoutData(data); |
| |
| data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, 0); |
| data.right = new FlatFormAttachment(outputVariableText, |
| -IDetailsAreaConstants.HSPACE); |
| data.top = new FlatFormAttachment(outputVariableText, 0, SWT.CENTER); |
| outputVariableLabel.setLayoutData(data); |
| |
| return composite; |
| } |
| |
| private void createPartMappingRows(ILabelProvider labelProvider, |
| final EObject model, List<Part> messageParts, Group refGroup, |
| EObject fromPartsOrToParts, final boolean isFromParts) { |
| |
| FlatFormData data; |
| CLabel ref = null; |
| |
| for (final Part part : messageParts) { |
| |
| boolean isFirst = ref == null; |
| |
| // create text |
| final Text text = fWidgetFactory.createText(refGroup, EMPTY_STRING); |
| Variable var = null; |
| // get the variable from a fromPart |
| if (isFromParts) { |
| FromParts fromParts = (FromParts) fromPartsOrToParts; |
| if (fromParts != null && !fromParts.getChildren().isEmpty()) { |
| for (FromPart fromPart : fromParts.getChildren()) { |
| if (fromPart.getPart() != null |
| && fromPart.getPart().equals(part)) { |
| var = fromPart.getToVariable(); |
| break; |
| } |
| } |
| } |
| } |
| // get the variable from a toPart |
| else { |
| ToParts toParts = (ToParts) fromPartsOrToParts; |
| if (toParts != null && !toParts.getChildren().isEmpty()) { |
| for (ToPart toPart : toParts.getChildren()) { |
| if (toPart.getPart() != null |
| && toPart.getPart().equals(part)) { |
| var = toPart.getFromVariable(); |
| break; |
| } |
| } |
| } |
| } |
| if (var != null) { |
| text.setText(var.getName()); |
| } else { |
| text.setText(EMPTY_STRING); |
| } |
| |
| Button button = null; |
| if (model instanceof OnEvent == false) { |
| text.setEditable(false); |
| |
| // create button |
| button = fWidgetFactory.createButton(refGroup, EMPTY_STRING, |
| SWT.ARROW | SWT.DOWN | SWT.CENTER); |
| |
| // align button |
| data = new FlatFormData(); |
| data.right = new FlatFormAttachment(100, |
| -IDetailsAreaConstants.HSPACE); |
| data.top = new FlatFormAttachment(text, +2, SWT.TOP); |
| data.bottom = new FlatFormAttachment(text, -2, SWT.BOTTOM); |
| button.setLayoutData(data); |
| } |
| |
| // align text |
| data = new FlatFormData(); |
| if (isFirst) { |
| data.top = new FlatFormAttachment(0, |
| IDetailsAreaConstants.VSPACE); |
| } else { |
| data.top = new FlatFormAttachment(ref, |
| IDetailsAreaConstants.VSPACE); |
| } |
| data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth( |
| ref, STANDARD_LABEL_WIDTH_LRG)); |
| if (button == null) { |
| data.right = new FlatFormAttachment(100, |
| -IDetailsAreaConstants.HSPACE); |
| } else { |
| data.right = new FlatFormAttachment(button, |
| -IDetailsAreaConstants.HSPACE); |
| } |
| text.setLayoutData(data); |
| |
| // create label |
| ref = new CLabel(refGroup, SWT.LEFT); |
| ref.setText(labelProvider.getText(part)); |
| ref.setImage(labelProvider.getImage(part)); |
| ref.setBackground(refGroup.getBackground()); |
| |
| // align label |
| data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, IDetailsAreaConstants.HSPACE); |
| data.right = new FlatFormAttachment(text, |
| -IDetailsAreaConstants.HSPACE); |
| data.top = new FlatFormAttachment(text, 0, SWT.CENTER); |
| ref.setLayoutData(data); |
| |
| /* |
| * CONTENT ASSIST |
| */ |
| RunnableProposal proposal1 = new RunnableProposal() { |
| |
| @Override |
| public String getLabel() { |
| return "Create global Variable"; |
| } |
| |
| public void run() { |
| createVariableForPartMapping(BPELUtils.getProcess(model), |
| model, part, isFromParts); |
| } |
| |
| }; |
| |
| RunnableProposal proposal2 = new RunnableProposal() { |
| |
| @Override |
| public String getLabel() { |
| return "Create local Variable"; |
| } |
| |
| public void run() { |
| createVariableForPartMapping(model, model, part, |
| isFromParts); |
| } |
| |
| }; |
| |
| RunnableProposal proposal3 = new RunnableProposal() { |
| |
| @Override |
| public String getLabel() { |
| return "Clear Variable"; |
| } |
| |
| public void run() { |
| Command cmd = null; |
| if (isFromParts) { |
| cmd = new AddFromPartCommand(model, null, part); |
| } else { |
| cmd = new AddToPartCommand(model, null, part); |
| } |
| getCommandFramework().execute(cmd); |
| } |
| |
| }; |
| |
| VariableFilter filter = new VariableFilter(); |
| if (part.getElementDeclaration() != null) { |
| filter.setType(part.getElementDeclaration()); |
| } else if (part.getTypeDefinition() != null) { |
| filter.setType(part.getTypeDefinition()); |
| } |
| VariableContentProvider provider = new VariableContentProvider(); |
| ModelContentProposalProvider proposalProvider = new ModelContentProposalProvider( |
| new ModelContentProposalProvider.ValueProvider() { |
| |
| @Override |
| public Object value() { |
| return getInput(); |
| } |
| |
| }, provider, filter); |
| |
| proposalProvider.addProposalToEnd(new Separator()); |
| proposalProvider.addProposalToEnd(proposal1); |
| proposalProvider.addProposalToEnd(proposal2); |
| proposalProvider.addProposalToEnd(proposal3); |
| |
| final FieldAssistAdapter contentAssist = new FieldAssistAdapter( |
| text, fTextContentAdapter, proposalProvider, null, null, |
| true); |
| contentAssist.setLabelProvider(labelProvider); |
| contentAssist.setPopupSize(new Point(300, 100)); |
| contentAssist |
| .setFilterStyle(ContentProposalAdapter.FILTER_CUMULATIVE); |
| contentAssist |
| .setProposalAcceptanceStyle(ContentProposalAdapter.PROPOSAL_REPLACE); |
| contentAssist.addContentProposalListener(proposal1); |
| contentAssist.addContentProposalListener(proposal2); |
| contentAssist.addContentProposalListener(proposal3); |
| contentAssist |
| .addContentProposalListener(new IContentProposalListener() { |
| |
| public void proposalAccepted(IContentProposal proposal) { |
| if (proposal.getContent() == null) { |
| return; |
| } |
| Variable variable = null; |
| try { |
| variable = (Variable) ((Adapter) proposal) |
| .getTarget(); |
| } catch (Throwable t) { |
| return; |
| } |
| |
| Command cmd = null; |
| if (isFromParts) { |
| cmd = new AddFromPartCommand(model, variable, |
| part); |
| } else { |
| cmd = new AddToPartCommand(model, variable, |
| part); |
| } |
| getCommandFramework().execute(cmd); |
| } |
| |
| }); |
| |
| // End of Content Assist for variable |
| if (button != null) { |
| button.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| contentAssist.openProposals(); |
| } |
| }); |
| } else if (model instanceof OnEvent) { |
| IOngoingChange change = new IOngoingChange() { |
| |
| public Command createApplyCommand() { |
| OnEvent onEvent = (OnEvent) model; |
| String s = text.getText(); |
| if (EMPTY_STRING.equals(s)) { |
| s = null; |
| } |
| CompoundCommand ccmd = new CompoundCommand(); |
| FromParts fromParts = onEvent.getFromParts(); |
| FromPart fromPart = null; |
| Variable variable = null; |
| if (fromParts != null |
| && fromParts.getChildren() != null) { |
| for (FromPart fp : fromParts.getChildren()) { |
| if (part.equals(fp.getPart())) { |
| fromPart = fp; |
| } |
| } |
| } |
| if (s != null) { |
| if (fromPart != null) { |
| variable = fromPart.getToVariable(); |
| } |
| if (variable == null) { |
| variable = BPELFactory.eINSTANCE |
| .createVariable(); |
| // set the variable's type to the part's type |
| variable.setType(part.getTypeDefinition()); |
| variable.setXSDElement(part |
| .getElementDeclaration()); |
| } |
| variable.setName(s); |
| ccmd.add(new AddFromPartCommand(onEvent, variable, |
| part)); |
| } else { |
| ccmd |
| .add(new AddFromPartCommand(onEvent, null, |
| part)); |
| } |
| return ccmd; |
| } |
| |
| public String getLabel() { |
| return IBPELUIConstants.CMD_SELECT_VARIABLE; |
| } |
| |
| public void restoreOldState() { |
| updatePartMappingWidgets(); |
| } |
| |
| }; |
| ChangeTracker onEventVariableTracker = new ChangeTracker(text, |
| change, getCommandFramework()); |
| onEventVariableTracker.startTracking(); |
| } |
| } |
| } |
| |
| /** |
| * Create an input variable, set it to the right type, and set the input |
| * variable pon the activity. |
| * |
| * @param ref |
| * the object on which to create the variable (Scope or Process) |
| * @param name |
| * the name of the variable, or null |
| * @param the |
| * direction of the variable |
| */ |
| |
| private void createVariable(EObject ref, String name, int direction) { |
| |
| Variable variable = BPELFactory.eINSTANCE.createVariable(); |
| |
| if (name == null) { |
| name = plainLabelWordFor(direction); |
| } |
| |
| Message messageType = null; |
| XSDElementDeclaration elementType = null; |
| |
| Object type = ModelHelper.getVariableType(getInput(), direction); |
| |
| if (type != null && type instanceof Message) { |
| messageType = (Message) type; |
| if (messageType.getEParts().size() == 1) { |
| Part part = (Part) messageType.getEParts().get(0); |
| elementType = part.getElementDeclaration(); |
| } |
| } |
| |
| // ask for the name, we know the type. |
| NameDialog nameDialog = new NameDialog(inputVariableComposite |
| .getShell(), Messages.VariableSelectorDialog_New_Variable_4, |
| Messages.VariableSelectorDialog_Variable_Name_5, name, BPELUtil |
| .getNCNameValidator()); |
| |
| if (nameDialog.open() == Window.CANCEL) { |
| return; |
| } |
| |
| // set name and type |
| variable.setName(nameDialog.getValue()); |
| |
| if (elementType != null) { |
| variable.setXSDElement(elementType); |
| } else if (messageType != null) { |
| variable.setMessageType(messageType); |
| } |
| |
| // create the variable and then set the input variable to it. |
| CompoundCommand cmd = new CompoundCommand(); |
| cmd.add(new AddVariableCommand(ref, variable)); |
| cmd.add(new SetVariableCommand(getInput(), variable, direction)); |
| |
| getCommandFramework().execute(cmd); |
| } |
| |
| private void createVariableForPartMapping(EObject ref, EObject model, |
| Part part, boolean isFromPart) { |
| |
| Variable variable = BPELFactory.eINSTANCE.createVariable(); |
| |
| // set the variable's type to the part's type |
| if (part.getTypeDefinition() != null) { |
| variable.setType(part.getTypeDefinition()); |
| } else if (part.getElementDeclaration() != null) { |
| variable.setXSDElement(part.getElementDeclaration()); |
| } |
| |
| // let the user choose a name for the variable |
| NameDialog nameDialog = new NameDialog(inputVariableComposite |
| .getShell(), Messages.VariableSelectorDialog_New_Variable_4, |
| Messages.VariableSelectorDialog_Variable_Name_5, null, BPELUtil |
| .getNCNameValidator()); |
| if (nameDialog.open() == Window.CANCEL) { |
| return; |
| } |
| variable.setName(nameDialog.getValue()); |
| |
| CompoundCommand cmd = new CompoundCommand(); |
| cmd.add(new AddVariableCommand(ref, variable)); |
| if (isFromPart) { |
| cmd.add(new AddFromPartCommand(model, variable, part)); |
| } else { |
| cmd.add(new AddToPartCommand(model, variable, part)); |
| } |
| |
| getCommandFramework().execute(cmd); |
| } |
| |
| private void createWidgets(Composite composite) { |
| |
| this.parentComposite = composite; |
| |
| // create the widgets |
| this.usePartMappingCheckbox = fWidgetFactory.createButton(composite, |
| "Use WSDL Message Parts Mapping", SWT.CHECK); |
| this.usePartMappingCheckbox |
| .addSelectionListener(new UsePartMappingCheckboxSelectionListener()); |
| |
| this.nonPartMappingComposite = createFlatFormComposite(composite); |
| Composite ref = createInputVariableWidgets(null, |
| nonPartMappingComposite); |
| createOutputVariableWidgets(ref, nonPartMappingComposite); |
| |
| // part mapping composite |
| this.partMappingComposite = createFlatFormComposite(composite); |
| |
| // layout the widgets |
| FlatFormData ffd = new FlatFormData(); |
| ffd.top = new FlatFormAttachment(0, 0); |
| ffd.left = new FlatFormAttachment(0, IDetailsAreaConstants.HSPACE); |
| this.usePartMappingCheckbox.setLayoutData(ffd); |
| |
| ffd = new FlatFormData(); |
| ffd.top = new FlatFormAttachment(this.usePartMappingCheckbox, |
| IDetailsAreaConstants.VSPACE); |
| ffd.left = new FlatFormAttachment(0, 0); |
| ffd.right = new FlatFormAttachment(100, 0); |
| this.partMappingComposite.setLayoutData(ffd); |
| |
| ffd = new FlatFormData(); |
| ffd.top = new FlatFormAttachment(this.usePartMappingCheckbox, |
| IDetailsAreaConstants.VSPACE); |
| ffd.left = new FlatFormAttachment(0, 0); |
| ffd.right = new FlatFormAttachment(100, 0); |
| this.nonPartMappingComposite.setLayoutData(ffd); |
| } |
| |
| private void findAndSetOrCreateVariable(String text, int direction) { |
| |
| text = text.trim(); |
| EObject model = getInput(); |
| |
| SetVariableCommand cmd = new SetVariableCommand(getInput(), null, |
| direction); |
| if (text.length() > 0) { |
| Variable variable = (Variable) ModelHelper |
| .findElementByName(ModelHelper.getContainingScope(model), |
| text, Variable.class); |
| if (variable == null) { |
| |
| createVariable(getInput(), text, direction); |
| return; |
| } |
| |
| cmd.setNewValue(variable); |
| } |
| |
| getCommandFramework().execute(cmd); |
| } |
| |
| /** |
| * Answer, based on the model, whether we should display "Fault" instead of |
| * "Response". |
| */ |
| private boolean getDisplayFault() { |
| EObject model = getModel(); |
| if (model instanceof Reply) { |
| Reply reply = (Reply) model; |
| if (reply.getFaultName() != null) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean isInvoke() { |
| return (getInput() instanceof Invoke); |
| } |
| |
| private boolean isReply() { |
| return getInput() instanceof Reply; |
| } |
| |
| private boolean isReceive() { |
| // https://issues.jboss.org/browse/JBIDE-8048 |
| // OnEvent is also a type of Receive |
| return getInput() instanceof Receive || getInput() instanceof OnMessage || getInput() instanceof OnEvent; |
| } |
| |
| /** |
| * The same as labelWordFor(), except these strings don't contain mnemonics! |
| * |
| * @param direction |
| * @return the label |
| */ |
| private String plainLabelWordFor(int direction) { |
| if (isInvoke()) { |
| return (direction == ModelHelper.OUTGOING || direction == ModelHelper.NOT_SPECIFIED) ? Messages.InvokeImplDetails_Request_3_Plain |
| : Messages.InvokeImplDetails_Response_4_Plain; |
| } |
| return (direction == ModelHelper.OUTGOING || direction == ModelHelper.NOT_SPECIFIED) ? Messages.InvokeImplDetails_Response_4_Plain |
| : Messages.InvokeImplDetails_Request_3_Plain; |
| } |
| |
| @Override |
| public void refresh() { |
| super.refresh(); |
| |
| boolean showPartMappingComposite = this.usePartMappingCheckbox |
| .getSelection(); |
| updateWidgets(showPartMappingComposite); |
| |
| if (showPartMappingComposite) { |
| updatePartMappingWidgets(); |
| } else { |
| updateInputVariableWidgets(); |
| updateOutputVariableWidgets(); |
| } |
| } |
| |
| private boolean shouldUsePartMapping(EObject model) { |
| |
| boolean shouldUsePartMapping = false; |
| |
| if (model instanceof Reply || model instanceof Invoke) { |
| shouldUsePartMapping = true; |
| if (ModelHelper.getVariable(model, ModelHelper.OUTGOING) != null) { |
| return false; |
| } |
| } |
| |
| if (model instanceof Receive || model instanceof Invoke |
| || model instanceof OnMessage || model instanceof OnEvent) { |
| shouldUsePartMapping = true; |
| if (ModelHelper.getVariable(model, ModelHelper.INCOMING) != null) { |
| return false; |
| } |
| } |
| |
| return shouldUsePartMapping; |
| } |
| |
| private void updateInputVariableWidgets() { |
| |
| inputVariableComposite.setVisible(!isReply()); |
| if (getInput() instanceof OnEvent) { |
| // https://issues.jboss.org/browse/JBIDE-8048 |
| // hide the proposal drop-down button - user must enter variable name |
| inputVariableButton.setVisible(false); |
| } |
| |
| if (isReply()) |
| return; |
| |
| if (isInvoke()) { |
| inputVariableLabel.setText(Messages.InvokeImplSection_22); |
| } else { |
| inputVariableLabel.setText(Messages.InvokeImplSection_23); |
| } |
| |
| Variable inputVar = ModelHelper.getVariable(getInput(), |
| isInvoke() ? ModelHelper.OUTGOING : ModelHelper.INCOMING); |
| |
| if (inputVar != null) { |
| inputVariableText.setText(inputVar.getName()); |
| } else { |
| inputVariableText.setText(EMPTY_STRING); |
| } |
| |
| // Figure out the type of the message. |
| fInputVariableFilter.clear(); |
| Object type = ModelHelper.getVariableType(getInput(), |
| isInvoke() ? ModelHelper.OUTGOING : ModelHelper.INCOMING); |
| if (type != null && type instanceof Message) { |
| fInputVariableFilter.setType((Message) type); |
| } |
| } |
| |
| private void updateOutputVariableWidgets() { |
| |
| outputVariableComposite.setVisible(!isReceive()); |
| |
| if (isReceive()) { |
| return; |
| } |
| |
| if (isInvoke()) { |
| outputVariableLabel.setText(Messages.InvokeImplSection_13); |
| } else { |
| outputVariableLabel.setText(Messages.InvokeImplSection_23); |
| } |
| |
| Variable outputVar = ModelHelper.getVariable(getInput(), |
| isInvoke() ? ModelHelper.INCOMING : ModelHelper.OUTGOING); |
| if (outputVar != null) { |
| outputVariableText.setText(outputVar.getName()); |
| } else { |
| outputVariableText.setText(EMPTY_STRING); |
| } |
| |
| // Figure out the type of the message. |
| fOutputVariableFilter.clear(); |
| Object type = ModelHelper.getVariableType(getInput(), |
| isInvoke() ? ModelHelper.INCOMING : ModelHelper.OUTGOING); |
| if (type != null) { |
| if (type instanceof Message) { |
| fOutputVariableFilter.setType((Message) type); |
| } |
| } |
| } |
| |
| private void updatePartMappingWidgets() { |
| |
| ILabelProvider labelProvider = new ModelLabelProvider(); |
| |
| final EObject model = getModel(); |
| |
| boolean showInputs = ModelHelper.isMessageActivity(model, |
| (isInvoke() ? ModelHelper.OUTGOING : ModelHelper.INCOMING)); |
| boolean showFaults = getDisplayFault(); |
| boolean showOutputs = !showFaults |
| && ModelHelper.isMessageActivity(model, |
| (isInvoke() ? ModelHelper.INCOMING |
| : ModelHelper.OUTGOING)); |
| |
| Operation operation = ModelHelper.getOperation(model); |
| |
| if (operation != null && !operation.eIsProxy()) { |
| |
| this.usePartMappingCheckbox.setEnabled(true); |
| |
| List<Part> inputParts = Collections.emptyList(); |
| if (showInputs) { |
| inputParts = PartMappingUtil.getPartsForPartMapping(operation, |
| WSDLConstants.INPUT, null); |
| } |
| |
| List<Part> outputParts = Collections.emptyList(); |
| if (showOutputs) { |
| outputParts = PartMappingUtil.getPartsForPartMapping(operation, |
| WSDLConstants.OUTPUT, null); |
| } |
| |
| List<Part> faultParts = Collections.emptyList(); |
| if (showFaults) { |
| String faultName = ModelHelper.getFaultName(model); |
| if (faultName != null) { |
| faultParts = PartMappingUtil.getPartsForPartMapping( |
| operation, WSDLConstants.FAULT, faultName); |
| } |
| } |
| |
| Group refGroup = null; |
| // print out all input parts |
| if (inputParts.size() > 0) { |
| |
| FromParts fromParts = ModelHelper.getFromParts(model); |
| |
| FlatFormData data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, |
| IDetailsAreaConstants.HSPACE); |
| data.right = new FlatFormAttachment(100, |
| -IDetailsAreaConstants.HSPACE); |
| if (refGroup != null) { |
| data.top = new FlatFormAttachment(refGroup, |
| IDetailsAreaConstants.VSPACE); |
| } else { |
| data.top = new FlatFormAttachment(0, |
| IDetailsAreaConstants.VSPACE); |
| } |
| refGroup = fWidgetFactory.createGroup( |
| this.partMappingComposite, "Input(s)"); |
| refGroup.setLayoutData(data); |
| refGroup.setLayout(new FlatFormLayout()); |
| |
| createPartMappingRows(labelProvider, model, inputParts, |
| refGroup, fromParts, true); |
| } |
| |
| // print out all output parts |
| if (outputParts.size() > 0) { |
| |
| ToParts toParts = ModelHelper.getToParts(model); |
| |
| FlatFormData data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, |
| IDetailsAreaConstants.HSPACE); |
| data.right = new FlatFormAttachment(100, |
| -IDetailsAreaConstants.HSPACE); |
| if (refGroup != null) { |
| data.top = new FlatFormAttachment(refGroup, |
| IDetailsAreaConstants.VSPACE); |
| } else { |
| data.top = new FlatFormAttachment(0, |
| IDetailsAreaConstants.VSPACE); |
| } |
| refGroup = fWidgetFactory.createGroup( |
| this.partMappingComposite, "Output(s)"); |
| refGroup.setLayoutData(data); |
| refGroup.setLayout(new FlatFormLayout()); |
| |
| createPartMappingRows(labelProvider, model, outputParts, |
| refGroup, toParts, false); |
| } |
| |
| // print out all fault parts |
| if (faultParts.size() > 0) { |
| |
| ToParts toParts = ModelHelper.getToParts(model); |
| |
| FlatFormData data = new FlatFormData(); |
| data.left = new FlatFormAttachment(0, |
| IDetailsAreaConstants.HSPACE); |
| data.right = new FlatFormAttachment(100, |
| -IDetailsAreaConstants.HSPACE); |
| if (refGroup != null) { |
| data.top = new FlatFormAttachment(refGroup, |
| IDetailsAreaConstants.VSPACE); |
| } else { |
| data.top = new FlatFormAttachment(0, |
| IDetailsAreaConstants.VSPACE); |
| } |
| refGroup = fWidgetFactory.createGroup( |
| this.partMappingComposite, "Fault(s)"); |
| refGroup.setLayoutData(data); |
| refGroup.setLayout(new FlatFormLayout()); |
| |
| createPartMappingRows(labelProvider, model, faultParts, |
| refGroup, toParts, false); |
| } |
| this.parentComposite.layout(true); |
| } else { |
| // TODO - we have an OperationProxy. What shall we do??? |
| this.usePartMappingCheckbox.setEnabled(false); |
| } |
| } |
| |
| private void updateWidgets(boolean showPartMappingComposite) { |
| |
| if (this.partMappingComposite != null) { |
| this.partMappingComposite.dispose(); |
| } |
| this.partMappingComposite = createFlatFormComposite(this.parentComposite); |
| FlatFormData ffd = new FlatFormData(); |
| ffd.top = new FlatFormAttachment(this.usePartMappingCheckbox, |
| IDetailsAreaConstants.VSPACE); |
| ffd.left = new FlatFormAttachment(0, 0); |
| ffd.right = new FlatFormAttachment(100, 0); |
| this.partMappingComposite.setLayoutData(ffd); |
| |
| if (!showPartMappingComposite) { |
| this.usePartMappingCheckbox.setSelection(false); |
| this.partMappingComposite.setVisible(false); |
| this.nonPartMappingComposite.setVisible(true); |
| } else { |
| this.usePartMappingCheckbox.setSelection(true); |
| this.partMappingComposite.setVisible(true); |
| this.nonPartMappingComposite.setVisible(false); |
| } |
| } |
| } |