/*******************************************************************************
* Copyright (c) 2005, 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.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import javax.xml.namespace.QName;
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.model.Activity;
import org.eclipse.bpel.model.BPELFactory;
import org.eclipse.bpel.model.BPELPackage;
import org.eclipse.bpel.model.Catch;
import org.eclipse.bpel.model.CatchAll;
import org.eclipse.bpel.model.ElseIf;
import org.eclipse.bpel.model.FaultHandler;
import org.eclipse.bpel.model.Flow;
import org.eclipse.bpel.model.If;
import org.eclipse.bpel.model.Import;
import org.eclipse.bpel.model.Invoke;
import org.eclipse.bpel.model.OnAlarm;
import org.eclipse.bpel.model.OnMessage;
import org.eclipse.bpel.model.PartnerLink;
import org.eclipse.bpel.model.Pick;
import org.eclipse.bpel.model.Process;
import org.eclipse.bpel.model.RepeatUntil;
import org.eclipse.bpel.model.Scope;
import org.eclipse.bpel.model.Sequence;
import org.eclipse.bpel.model.Throw;
import org.eclipse.bpel.model.Variable;
import org.eclipse.bpel.model.While;
import org.eclipse.bpel.model.partnerlinktype.Role;
import org.eclipse.bpel.model.util.BPELConstants;
import org.eclipse.bpel.model.util.BPELUtils;
import org.eclipse.bpel.ui.IBPELUIConstants;
import org.eclipse.bpel.ui.IHelpContextIds;
import org.eclipse.bpel.ui.Messages;
import org.eclipse.bpel.ui.commands.CompoundCommand;
import org.eclipse.bpel.ui.commands.SetFaultNameCommand;
import org.eclipse.bpel.ui.commands.SetFaultNamespaceCommand;
import org.eclipse.bpel.ui.commands.SetNameCommand;
import org.eclipse.bpel.ui.commands.SetVariableCommand;
import org.eclipse.bpel.ui.commands.SetVariableKindCommand;
import org.eclipse.bpel.ui.commands.util.AutoUndoCommand;
import org.eclipse.bpel.ui.dialogs.TypeSelectorDialog;
import org.eclipse.bpel.ui.uiextensionmodel.VariableExtension;
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.NamespaceUtils;
import org.eclipse.bpel.ui.util.WSDLImportHelper;
import org.eclipse.core.runtime.Assert;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.gef.commands.Command;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.Fault;
import org.eclipse.wst.wsdl.Message;
import org.eclipse.wst.wsdl.Operation;
import org.eclipse.wst.wsdl.PortType;
import org.eclipse.wst.wsdl.util.WSDLConstants;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDTypeDefinition;
/**
* Details section for the fault name referenced in a Catch.
*/
public class FaultCatchNameSection extends BPELPropertySection {
protected static final int NAME_BUILTIN_CONTEXT = 0;
protected static final int NAMESPACE_CONTEXT = 1;
protected static final int VARIABLE_CONTEXT = 2;
protected static final int BUILTINRADIO_CONTEXT = 3;
protected static final int USERDEFRADIO_CONTEXT = 4;
protected static final int NAME_USERDEF_CONTEXT = 5;
protected static final int FAULT_VARIABLE_NAME_CONTEXT = 6;
protected static final int FAULT_VARIABLE_TYPE_CONTEXT = 7;
protected int lastChangeContext = -1;
protected VariableTypeSelector variableTypeSelector;
protected boolean isCatch, isFaultTypeEnabled;
protected Composite parentComposite;
protected Composite faultTypeComposite, namespaceComposite, faultNameComposite, faultUserDefNameComposite, faultVariableNameComposite;
protected Button builtinRadio, userdefRadio;
protected Text variableNameText;
protected CCombo faultNameCombo, faultUserDefCombo, faultNamespaceCombo;
protected ChangeTracker faultNameTracker, faultNamespaceTracker,
faultUserDefNameTracker, variableNameTracker;
protected Vector<QName> faultNameQNames;
public FaultCatchNameSection() {
super();
}
@Override
protected MultiObjectAdapter[] createAdapters() {
return new BatchedMultiObjectAdapter[] {
/* model object */
new BatchedMultiObjectAdapter() {
boolean refreshFaultName = false;
boolean refreshUserDefFaultName = false;
boolean refreshFaultNamespace = false;
boolean refreshVariable = false;
@Override
public void notify(Notification n) {
if (ModelHelper.isFaultNameAffected(getInput(), n) && builtinRadio.getSelection()) {
refreshFaultName = true;
}
if (ModelHelper.isFaultNameAffected(getInput(), n) && userdefRadio.getSelection()) {
refreshUserDefFaultName = true;
}
if (isFaultTypeEnabled && ModelHelper.isFaultNamespaceAffected(getInput(), n)) {
refreshFaultNamespace = true;
}
if (ModelHelper.isVariableAffected(getInput(), n, ModelHelper.INCOMING)) {
refreshVariable = true;
} else if (n.getFeatureID(Catch.class) == BPELPackage.CATCH__FAULT_MESSAGE_TYPE) {
refreshVariable = true;
}
}
@Override
public void finish() {
if (refreshFaultName) updateFaultNameWidgets();
if (refreshFaultNamespace) updateFaultNamespaceWidgets();
if (refreshUserDefFaultName) updateUserDefFaultNameWidgets();
if (refreshVariable) updateVariableWidgets();
refreshFaultName = false;
refreshUserDefFaultName = false;
refreshFaultNamespace = false;
refreshVariable = false;
}
},
};
}
protected boolean isNamespaceUserDef() {
return (!isFaultTypeEnabled) || userdefRadio.getSelection();
}
protected void doChildLayout() {
FlatFormData data = null;
FlatFormData data1 = null;
boolean isNamespaceUserDef = isNamespaceUserDef();
if (isFaultTypeEnabled) {
data = (FlatFormData)namespaceComposite.getLayoutData();
data.top = new FlatFormAttachment(faultTypeComposite, IDetailsAreaConstants.VSPACE);
if (isNamespaceUserDef) {
data = (FlatFormData)faultUserDefNameComposite.getLayoutData();
data.top = new FlatFormAttachment(namespaceComposite, IDetailsAreaConstants.VSPACE);
data1 = (FlatFormData)faultVariableNameComposite.getLayoutData();
data1.top = new FlatFormAttachment(faultUserDefNameComposite, IDetailsAreaConstants.VSPACE);
} else {
data = (FlatFormData)faultNameComposite.getLayoutData();
data.top = new FlatFormAttachment(faultTypeComposite, IDetailsAreaConstants.VSPACE);
data1 = (FlatFormData)faultVariableNameComposite.getLayoutData();
data1.top = new FlatFormAttachment(faultNameComposite, IDetailsAreaConstants.VSPACE);
}
} else {
data = (FlatFormData)namespaceComposite.getLayoutData();
data.top = new FlatFormAttachment(0, 0);
// note: isNamespaceUserDef == true
data = (FlatFormData)faultUserDefNameComposite.getLayoutData();
data.top = new FlatFormAttachment(namespaceComposite, IDetailsAreaConstants.VSPACE);
data1 = (FlatFormData)faultVariableNameComposite.getLayoutData();
data1.top = new FlatFormAttachment(faultUserDefNameComposite, IDetailsAreaConstants.VSPACE);
}
faultTypeComposite.setVisible(isFaultTypeEnabled);
namespaceComposite.setVisible(isNamespaceUserDef);
faultNameComposite.setVisible(!isNamespaceUserDef);
faultUserDefNameComposite.setVisible(isNamespaceUserDef);
parentComposite.layout(true);
parentComposite.getParent().layout(true);
}
@Override
public boolean shouldUseExtraSpace() {
return true;
}
@Override
protected void basicSetInput(EObject input) {
super.basicSetInput(input);
rearrangeWidgets();
}
protected void rearrangeWidgets() {
isCatch = (getInput() instanceof Catch);
isFaultTypeEnabled = true;
if (isCatch) {
FaultHandler faultHandler = (FaultHandler)getInput().eContainer();
if (faultHandler != null) {
Object maybeInvoke = faultHandler.eContainer();
if (maybeInvoke instanceof Invoke) isFaultTypeEnabled = false;
}
}
doChildLayout();
}
protected void createFaultTypeWidgets(Composite parent) {
FlatFormData data;
Composite composite = faultTypeComposite = createFlatFormComposite(parent);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(100, 0);
data.top = new FlatFormAttachment(0, 0);
composite.setLayoutData(data);
Label faultTypeLabel = fWidgetFactory.createLabel(composite, Messages.FaultCatchNameDetails_Fault_Type__13);
builtinRadio = fWidgetFactory.createButton(composite, Messages.FaultCatchNameDetails_Built_in_14, SWT.RADIO);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(faultTypeLabel, STANDARD_LABEL_WIDTH_SM));
// hack: fudge vertical alignment.
data.top = new FlatFormAttachment(0, 2);
builtinRadio.setLayoutData(data);
builtinRadio.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
if (!builtinRadio.getSelection()) return;
doChildLayout();
// hack!
updateFaultNameWidgets();
updateUserDefFaultNameWidgets();
CompoundCommand command = new CompoundCommand();
String newName = faultNameCombo.getText();
Command cmd = new SetFaultNameCommand(getInput(), isEmptyMessageType(newName) ? "" : newName);
if (cmd.canExecute()) command.add(cmd);
cmd = new SetFaultNamespaceCommand(getInput(), BPELConstants.NAMESPACE);
if (cmd.canExecute()) command.add(cmd);
command.setLabel(cmd.getLabel());
if (command.canExecute()) {
lastChangeContext = BUILTINRADIO_CONTEXT;
getCommandFramework().execute(wrapInShowContextCommand(command));
}
updateUserDefFaultNameWidgets();
updateFaultNameWidgets();
updateFaultNamespaceWidgets();
}
public void widgetDefaultSelected(SelectionEvent e) {
// Do nothing - widgetDefaultSelected is not called.
}
});
userdefRadio = fWidgetFactory.createButton(composite, Messages.FaultCatchNameDetails_User_defined_15, SWT.RADIO);
data = new FlatFormData();
data.left = new FlatFormAttachment(builtinRadio, IDetailsAreaConstants.HSPACE);
data.top = new FlatFormAttachment(0, 2);
userdefRadio.setLayoutData(data);
userdefRadio.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
if (!userdefRadio.getSelection()) return;
doChildLayout();
// hack!
String s = ""; //$NON-NLS-1$
Vector<QName> names = getFaultNames(getProcess().getTargetNamespace());
if (!names.isEmpty()) s = (names.get(0)).getLocalPart();
CompoundCommand command = new CompoundCommand();
Command cmd = new SetFaultNameCommand(getInput(), (s==null)? "" : s); //$NON-NLS-1$
if (cmd.canExecute()) command.add(cmd);
// Set the namespace to the process namespace.
cmd = new SetFaultNamespaceCommand(getInput(), getProcess().getTargetNamespace());
if (cmd.canExecute()) command.add(cmd);
if (command.canExecute()) {
lastChangeContext = USERDEFRADIO_CONTEXT;
getCommandFramework().execute(wrapInShowContextCommand(command));
}
updateUserDefFaultNameWidgets();
updateFaultNameWidgets();
updateFaultNamespaceWidgets();
}
public void widgetDefaultSelected(SelectionEvent e) {
// Do nothing - widgetDefaultSelected is not called.
}
});
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(builtinRadio, -IDetailsAreaConstants.HSPACE);
data.top = new FlatFormAttachment(builtinRadio, 0, SWT.CENTER);
faultTypeLabel.setLayoutData(data);
}
protected void createChangeTrackers() {
IOngoingChange change = new IOngoingChange() {
public String getLabel() {
return IBPELUIConstants.CMD_EDIT_FAULTNAME;
}
public Command createApplyCommand() {
String name = faultNameCombo.getText();
CompoundCommand command = new CompoundCommand();
String newName = "".equals(name)? null : name; //$NON-NLS-1$
Command newNameCommand = new SetFaultNameCommand(getInput(), isEmptyMessageType(newName) ? "" : newName);
if (newNameCommand.canExecute()) command.add(newNameCommand);
Command c2 = new SetFaultNamespaceCommand(getInput(), BPELConstants.NAMESPACE);
if (c2.canExecute()) command.add(c2);
lastChangeContext = NAME_BUILTIN_CONTEXT;
return wrapInShowContextCommand(command);
}
public void restoreOldState() {
updateFaultNameWidgets();
}
};
faultNameTracker = new ChangeTracker(faultNameCombo, change, getCommandFramework());
change = new IOngoingChange() {
public String getLabel() {
return IBPELUIConstants.CMD_EDIT_FAULTNAME;
}
public Command createApplyCommand() {
String s = NamespaceUtils.convertNamespaceToUri(faultNamespaceCombo.getText());
lastChangeContext = NAMESPACE_CONTEXT;
CompoundCommand command = new CompoundCommand();
command.add(new SetFaultNamespaceCommand(getInput(), "".equals(s)? null : s)); //$NON-NLS-1$
Vector<QName> faultNames = getFaultNames(s);
String name = null;
if (!faultNames.isEmpty()) {
name = (faultNames.get(0)).getLocalPart();
}
command.add(new SetFaultNameCommand(getInput(), isEmptyMessageType(name) ? "" : name));
return wrapInShowContextCommand(command);
}
public void restoreOldState() {
updateFaultNamespaceWidgets();
}
};
faultNamespaceTracker = new ChangeTracker(faultNamespaceCombo, change, getCommandFramework());
change = new IOngoingChange() {
public String getLabel() {
return IBPELUIConstants.CMD_EDIT_FAULTNAME;
}
public Command createApplyCommand() {
lastChangeContext = NAME_USERDEF_CONTEXT;
String faultName = faultUserDefCombo.getText();
String namespace = NamespaceUtils.convertNamespaceToUri(faultNamespaceCombo.getText());
if (!validNamespaceFaultNameCombination(namespace, faultName)) {
namespace = NamespaceUtils.convertUriToNamespace(getNamespaceByFaultName(faultName));
if (namespace == null) namespace = ""; //$NON-NLS-1$
}
faultNamespaceCombo.setText(NamespaceUtils.convertUriToNamespace(namespace));
CompoundCommand command = new CompoundCommand(IBPELUIConstants.CMD_EDIT_FAULTNAME);
command.add(new SetFaultNamespaceCommand(getInput(), "".equals(namespace) ? null : namespace)); //$NON-NLS-1$
String newName = "".equals(faultName) ? null : faultName;
command.add(new SetFaultNameCommand(getInput(), isEmptyMessageType(newName) ? "" : newName)); //$NON-NLS-1$
return wrapInShowContextCommand(command);
}
public void restoreOldState() {
updateUserDefFaultNameWidgets();
}
};
faultUserDefNameTracker = new ChangeTracker(faultUserDefCombo, change, getCommandFramework());
change = new IOngoingChange() {
public String getLabel() {
return IBPELUIConstants.CMD_SELECT_VARIABLE;
}
public Command createApplyCommand() {
final Catch _catch = (Catch)getInput();
String s = variableNameText.getText();
if ("".equals(s)) s = null; //$NON-NLS-1$
CompoundCommand result = new CompoundCommand();
Variable variable = _catch.getFaultVariable();
if (s != null) {
if (variable == null) {
variable = BPELFactory.eINSTANCE.createVariable();
result.add(new SetVariableCommand(_catch, variable, ModelHelper.INCOMING));
}
result.add(new SetNameCommand(variable, s));
} else {
if (variable != null) {
result.add(new SetVariableCommand(_catch, null, ModelHelper.INCOMING));
}
}
lastChangeContext = FAULT_VARIABLE_NAME_CONTEXT;
return wrapInShowContextCommand(result);
}
public void restoreOldState() {
updateVariableWidgets();
}
};
variableNameTracker = new ChangeTracker(variableNameText, change, getCommandFramework());
}
protected void createFaultNameWidgets(Composite parent) {
FlatFormData data;
Composite composite = faultNameComposite = createFlatFormComposite(parent);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(100, 0);
data.top = new FlatFormAttachment(namespaceComposite, IDetailsAreaConstants.VSPACE);
composite.setLayoutData(data);
faultNameCombo = fWidgetFactory.createCCombo(composite);
Label faultNameLabel = fWidgetFactory.createLabel(composite, Messages.FaultCatchNameDetails_Fault_Name__16);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(faultNameLabel, STANDARD_LABEL_WIDTH_SM));
data.right = new FlatFormAttachment(50,
-SHORT_BUTTON_WIDTH-IDetailsAreaConstants.HSPACE-IDetailsAreaConstants.CENTER_SPACE);
data.top = new FlatFormAttachment(0, 0);
List<String> faultNames = getBuiltinFaultNames();
String[] result = faultNames.toArray(new String[faultNames.size()]);
faultNameCombo.setItems(result);
faultNameCombo.setLayoutData(data);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(faultNameCombo, -IDetailsAreaConstants.HSPACE);
data.top = new FlatFormAttachment(faultNameCombo, 0, SWT.CENTER);
faultNameLabel.setLayoutData(data);
}
protected void createNamespaceWidgets(Composite parent) {
FlatFormData data;
final Composite composite = namespaceComposite = createFlatFormComposite(parent);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(100, 0);
data.top = new FlatFormAttachment(faultTypeComposite, IDetailsAreaConstants.VSPACE);
composite.setLayoutData(data);
faultNamespaceCombo = fWidgetFactory.createCCombo(composite);
Label faultNamespaceLabel = fWidgetFactory.createLabel(composite, Messages.FaultCatchNameDetails_Namespace__21);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(faultNamespaceLabel, STANDARD_LABEL_WIDTH_SM));
data.right = new FlatFormAttachment(50, -SHORT_BUTTON_WIDTH-IDetailsAreaConstants.HSPACE-IDetailsAreaConstants.CENTER_SPACE);
data.top = new FlatFormAttachment(0, +1);
faultNamespaceCombo.setLayoutData(data);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(faultNamespaceCombo, -IDetailsAreaConstants.HSPACE);
data.top = new FlatFormAttachment(faultNamespaceCombo, 0, SWT.CENTER);
faultNamespaceLabel.setLayoutData(data);
data = new FlatFormData();
data.right = new FlatFormAttachment(100, 0);
data.left = new FlatFormAttachment(100, -STANDARD_BUTTON_WIDTH);
data.top = new FlatFormAttachment(faultNamespaceCombo, -1, SWT.TOP);
data.bottom = new FlatFormAttachment(faultNamespaceCombo, +1, SWT.BOTTOM);
}
protected void createUserDefFaultNameWidgets(Composite parent) {
FlatFormData data;
Composite composite = faultUserDefNameComposite = createFlatFormComposite(parent);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(100, 0);
data.top = new FlatFormAttachment(namespaceComposite, IDetailsAreaConstants.VSPACE);
composite.setLayoutData(data);
Label faultUserDefNameLabel = fWidgetFactory.createLabel(composite, Messages.FaultCatchNameDetails_Fault_Name__24);
faultUserDefCombo = fWidgetFactory.createCCombo(composite, SWT.FLAT | SWT.READ_ONLY);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(faultUserDefNameLabel, STANDARD_LABEL_WIDTH_SM));
data.right = new FlatFormAttachment(50, -SHORT_BUTTON_WIDTH - IDetailsAreaConstants.HSPACE - IDetailsAreaConstants.CENTER_SPACE);
data.top = new FlatFormAttachment(0, +1);
faultUserDefCombo.setLayoutData(data);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(faultUserDefCombo, -IDetailsAreaConstants.HSPACE);
data.top = new FlatFormAttachment(faultUserDefCombo, 0, SWT.CENTER);
faultUserDefNameLabel.setLayoutData(data);
}
public class FaultVariableTypeCallback implements VariableTypeSelector.Callback {
protected void store(final EObject type) {
final Catch _catch = (Catch)getInput();
CompoundCommand command = new CompoundCommand();
command.add(new AutoUndoCommand(getProcess()) {
@Override
public void doExecute() {
Variable variable = _catch.getFaultVariable();
if (variable == null) {
variable = BPELFactory.eINSTANCE.createVariable();
_catch.setFaultVariable(variable);
}
// https://issues.jboss.org/browse/JBIDE-8045
// Data caught by fault handler can be either a Message Type
// or an XSD Element.
if (type instanceof Message) {
_catch.setFaultMessageType((Message)type);
_catch.setFaultElement(null);
}
else if (type instanceof XSDElementDeclaration) {
_catch.setFaultMessageType(null);
_catch.setFaultElement((XSDElementDeclaration)type);
}
}
});
getCommandFramework().execute(wrapInShowContextCommand(command));
}
public void selectRadioButton(final int index) {
final Catch _catch = (Catch)getInput();
Variable variable = _catch.getFaultVariable();
if (variable == null) {
variable = BPELFactory.eINSTANCE.createVariable();
}
final Variable variable2 = variable;
CompoundCommand command = new CompoundCommand();
command.add(new AutoUndoCommand(getProcess()) {
@Override
public void doExecute() {
if (_catch.getFaultVariable() != variable2) {
_catch.setFaultVariable(variable2);
}
ModelHelper.createExtensionIfNecessary(
getBPELEditor().getExtensionMap(), variable2);
_catch.setFaultMessageType(null);
VariableExtension varExt = (VariableExtension)ModelHelper.getExtension(variable2);
if ((varExt.getVariableKind() != index)) {
(new SetVariableKindCommand(varExt, index)).execute();
}
}
});
if (!command.isEmpty()) getCommandFramework().execute(wrapInShowContextCommand(command));
}
// https://issues.jboss.org/browse/JBIDE-8045
public void selectXSDType(XSDTypeDefinition xsdType) {
MessageDialog.openError(null, Messages.SelectionAndCreationDialog_Error_2,
Messages.FaultCatchNameSection_Error_Invalid_Type);
}
public void selectXSDElement(XSDElementDeclaration xsdElement) {
store(xsdElement);
}
public void selectMessageType(Message message) {
store(message);
}
}
protected void createVariableWidgets(Composite parent) {
FlatFormData data;
final Composite composite = faultVariableNameComposite = createFlatFormComposite(parent);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(100, 0);
data.top = new FlatFormAttachment(faultNameComposite, IDetailsAreaConstants.VSPACE);
composite.setLayoutData(data);
Label variableLabel = fWidgetFactory.createLabel(composite, Messages.FaultCatchNameSection_Variable_Name_3);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.top = new FlatFormAttachment(0, 0);
variableLabel.setLayoutData(data);
variableNameText = fWidgetFactory.createText(composite, ""); //$NON-NLS-1$
data = new FlatFormData();
data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(variableLabel, STANDARD_LABEL_WIDTH_SM));
data.right = new FlatFormAttachment(50, 0);
data.top = new FlatFormAttachment(0, 0);
variableNameText.setLayoutData(data);
variableNameText.addListener(SWT.Modify, new Listener() {
public void handleEvent(Event event) {
updateVariableTypeSelector();
}
});
// https://issues.jboss.org/browse/JBIDE-8045
variableTypeSelector = new VariableTypeSelector(composite, SWT.NONE, getBPELEditor(),
fWidgetFactory, new FaultVariableTypeCallback(), false,
TypeSelectorDialog.INCLUDE_ELEMENT_DECLARATIONS | TypeSelectorDialog.INCLUDE_MESSAGE_TYPES);
data = new FlatFormData();
data.top = new FlatFormAttachment(variableNameText, IDetailsAreaConstants.VSPACE+4);
data.left = new FlatFormAttachment(0,0);
data.right = new FlatFormAttachment(100,0);
data.bottom = new FlatFormAttachment(100,0);
variableTypeSelector.setLayoutData(data);
}
@Override
protected void createClient(Composite parent) {
parentComposite = createFlatFormComposite(parent);
createFaultTypeWidgets(parentComposite);
createUserDefFaultNameWidgets(parentComposite);
createNamespaceWidgets(parentComposite);
createFaultNameWidgets(parentComposite);
createVariableWidgets(parentComposite);
createChangeTrackers();
PlatformUI.getWorkbench().getHelpSystem().setHelp(
parentComposite, IHelpContextIds.PROPERTY_PAGE_FAULT);
}
protected void updateFaultNameWidgets() {
Assert.isNotNull(getInput());
faultNameTracker.stopTracking();
try {
String s = ModelHelper.getFaultName(getInput());
if (s == null || "".equals(s)) { //$NON-NLS-1$
faultNameCombo.setText(Messages.FaultCatchNameSection_None_0);
} else if (!s.equals(faultNameCombo.getText())) {
if (faultNameCombo.indexOf(s) == -1) s = ""; //$NON-NLS-1$
faultNameCombo.setText(s);
}
} finally {
faultNameTracker.startTracking();
}
}
protected void updateUserDefFaultNameWidgets() {
Assert.isNotNull(getInput());
faultUserDefNameTracker.stopTracking();
try {
String namespace = ModelHelper.getFaultNamespace(getInput());
Vector<QName> faultNames;
if (namespace == null)
faultNames = getFaultNames();
else faultNames = getFaultNames(namespace);
faultUserDefCombo.removeAll();
for (QName faultName : faultNames) {
if (faultUserDefCombo.indexOf(faultName.getLocalPart()) == -1) faultUserDefCombo.add(faultName.getLocalPart());
}
String s = ModelHelper.getFaultName(getInput());
if (s == null) s = ""; //$NON-NLS-1$
if (!s.equals(faultUserDefCombo.getText()))
{
if (faultUserDefCombo.indexOf(s) == -1) {
faultUserDefCombo.setText(""); //$NON-NLS-1$
} else {
faultUserDefCombo.setText(s);
}
}
} finally {
faultUserDefNameTracker.startTracking();
}
}
protected void updateFaultNamespaceWidgets() {
Assert.isNotNull(getInput());
faultNamespaceTracker.stopTracking();
try {
Vector<QName> namespaces = getFaultNames();
faultNamespaceCombo.removeAll();
for (QName qname : namespaces) {
String uri = NamespaceUtils.convertUriToNamespace(qname.getNamespaceURI());
if (faultNamespaceCombo.indexOf(uri) == -1)
faultNamespaceCombo.add(uri);
}
String s = ModelHelper.getFaultNamespace(getInput());
s = NamespaceUtils.convertUriToNamespace(s);
if (s == null)
s = ""; //$NON-NLS-1$
if (!s.equals(faultNamespaceCombo.getText())) {
if (faultNamespaceCombo.indexOf(s) == -1)
s = ""; //$NON-NLS-1$
faultNamespaceCombo.setText(s);
}
} finally {
faultNamespaceTracker.startTracking();
}
}
protected void updateFaultTypeWidgets() {
Assert.isNotNull(getInput());
String faultNamespace = ModelHelper.getFaultNamespace(getInput());
boolean isBuiltin = isBuiltinFault(faultNamespace);
builtinRadio.setSelection(isBuiltin);
userdefRadio.setSelection(!isBuiltin);
doChildLayout();
}
protected void updateVariableTypeSelector() {
Catch _catch = (Catch)getInput();
if (_catch.getFaultVariable() == null) {
variableTypeSelector.setVariableType(null);
String name = variableNameText.getText();
variableTypeSelector.setEnabled(name != null && !"".equals(name)); //$NON-NLS-1$
} else {
variableTypeSelector.setEnabled(true);
}
if (_catch.getFaultMessageType() != null) {
variableTypeSelector.setVariableType(_catch.getFaultMessageType());
}
// https://issues.jboss.org/browse/JBIDE-8045
if (_catch.getFaultElement() != null) {
variableTypeSelector.setVariableType(_catch.getFaultElement());
}
}
@Override
public void refresh() {
super.refresh();
updateFaultTypeWidgets();
updateFaultNamespaceWidgets();
updateUserDefFaultNameWidgets();
updateFaultNameWidgets();
updateVariableWidgets();
}
protected void updateVariableWidgets() {
variableNameTracker.stopTracking();
try {
Catch _catch = (Catch)getInput();
Variable variable = _catch.getFaultVariable();
if (variable == null) {
variableNameText.setText(""); //$NON-NLS-1$
} else {
variableNameText.setText(variable.getName() == null ? "" : variable.getName()); //$NON-NLS-1$
}
updateVariableTypeSelector();
} finally {
variableNameTracker.startTracking();
}
}
protected String getFaultNameByNamespace(String namespace) {
Vector<QName> faultNames = getFaultNames();
Assert.isNotNull(faultNames);
for (QName qname : faultNames) {
if (qname.getNamespaceURI().equals(namespace))
return qname.getLocalPart();
}
return null;
}
protected String getNamespaceByFaultName(String faultname) {
Vector<QName> faultNames = getFaultNames();
Assert.isNotNull(faultNames);
for (QName qname : faultNames) {
if (qname.getLocalPart().equals(faultname))
return qname.getNamespaceURI();
}
return null;
}
protected boolean validNamespaceFaultNameCombination(String namespace, String faultname) {
Vector<QName> faultNames = getFaultNames();
Assert.isNotNull(faultNames);
for (QName qname : faultNames) {
if (qname.getLocalPart().equals(faultname) && qname.getNamespaceURI().equals(namespace))
return true;
}
return false;
}
protected void getFaultNames(Object activity) {
EList<Activity> activities = null;
if (activity instanceof Sequence)
activities = ((Sequence) activity).getActivities();
if (activity instanceof Flow)
activities = ((Flow) activity).getActivities();
if (activity instanceof While)
getFaultNames(((While) activity).getActivity());
if (activity instanceof RepeatUntil)
getFaultNames(((RepeatUntil) activity).getActivity());
if (activity instanceof If) {
for (ElseIf elif : ((If) activity).getElseIf()) {
getFaultNames(elif.getActivity());
}
}
if (activity instanceof Pick) {
for (OnMessage onMessage : ((Pick) activity).getMessages()) {
getFaultNames(onMessage.getActivity());
}
for (OnAlarm onAlarm : ((Pick) activity).getAlarm()) {
getFaultNames(onAlarm.getActivity());
}
}
if (activity instanceof Scope) {
Scope scope = (Scope) activity;
FaultHandler faultHandler = scope.getFaultHandlers();
if (faultHandler != null) {
for (Catch c : faultHandler.getCatch()) {
getFaultNames(c.getActivity());
}
CatchAll catchAll = faultHandler.getCatchAll();
if (catchAll != null) {
getFaultNames(catchAll.getActivity());
}
}
getFaultNames(scope.getActivity());
}
if (activities != null) {
for (Activity subActivity : activities) {
getFaultNames(subActivity);
}
}
if (activity instanceof Throw) {
QName name = ((Throw)activity).getFaultName();
if (name != null) {
faultNameQNames.add(name);
}
}
}
protected Vector<QName> getFaultNames(String namespace) {
Vector<QName> result = new Vector<QName>();
for (QName qname : getFaultNames()) {
if (qname.getNamespaceURI().equals(namespace))
result.add(qname);
}
return result;
}
protected Vector<QName> getFaultNames() {
faultNameQNames = new Vector<QName>();
if (getInput() == null)
throw new IllegalStateException();
Process p = BPELUtils.getProcess(getInput());
// get FaultNames from activities
getFaultNames(p.getActivity());
for (PartnerLink partnerLink : p.getPartnerLinks().getChildren()) {
Role role = partnerLink.getMyRole();
if (role == null)
role = partnerLink.getPartnerRole();
if (role != null) {
PortType portType = (PortType)role.getPortType();
if (portType != null && !portType.eIsProxy()) {
for (Iterator operationsIterator = portType.getEOperations().iterator(); operationsIterator.hasNext();) {
Operation operation = (Operation) operationsIterator.next();
Map faults = operation.getFaults();
if (faults != null) {
if (faults.size() > 0) {
for (Iterator faultsIter = faults.values().iterator(); faultsIter.hasNext();) {
Fault fault = (Fault) faultsIter.next();
faultNameQNames.add(new QName(portType.getQName().getNamespaceURI(), fault.getName()));
}
}
}
}
}
}
}
return faultNameQNames;
}
public static class FaultCatchContext {
public int context;
public Object innerContext;
FaultCatchContext(int context) { this.context = context; }
}
@Override
public Object getUserContext() {
FaultCatchContext result = new FaultCatchContext(lastChangeContext);
if (lastChangeContext == FAULT_VARIABLE_TYPE_CONTEXT) {
result.innerContext = variableTypeSelector.getUserContext();
}
return result;
}
@Override
public void restoreUserContext(Object userContext) {
FaultCatchContext c = (FaultCatchContext)userContext;
switch (c.context) {
case NAME_BUILTIN_CONTEXT: faultNameCombo.setFocus(); return;
case NAMESPACE_CONTEXT: faultNamespaceCombo.setFocus(); return;
case BUILTINRADIO_CONTEXT: builtinRadio.setFocus(); return;
case USERDEFRADIO_CONTEXT: userdefRadio.setFocus(); return;
case NAME_USERDEF_CONTEXT: faultUserDefCombo.setFocus(); return;
case FAULT_VARIABLE_NAME_CONTEXT: variableNameText.setFocus(); return;
case FAULT_VARIABLE_TYPE_CONTEXT:
variableTypeSelector.restoreUserContext(c.innerContext); return;
}
throw new IllegalStateException();
}
private Command getCreateNewVariableCommand() {
return new AutoUndoCommand(getProcess()) {
@Override
public void doExecute() {
CompoundCommand result = new CompoundCommand();
// if the variable does not exist or does not have a type,
// create one and assign the best default type
Catch _catch = (Catch)getInput();
Variable variable = _catch.getFaultVariable();
QName faultQName = ModelHelper.getFaultQName(getInput());
Message type = getFaultMessage(faultQName);
variable = BPELFactory.eINSTANCE.createVariable();
variable.setMessageType(type);
result.add(new SetVariableCommand(_catch, variable, ModelHelper.INCOMING));
// set variable name command
String name = variableNameText.getText();
if (name == null || "".equals(name)) { //$NON-NLS-1$
String hint = BPELPackage.eINSTANCE.getVariable().getName();
name = BPELUtil.getUniqueModelName(getProcess(), hint, null);
}
result.add(new SetNameCommand(variable, name));
result.execute();
}
};
}
/**
* Gets the fault message from the fault qname.
*/
protected Message getFaultMessage(QName faultQName) {
if (faultQName == null || faultQName.getNamespaceURI() == null || faultQName.getLocalPart() == null) return null;
Definition[] definitions = getDefinitions(faultQName.getNamespaceURI());
for (int i = 0; i < definitions.length; i++) {
Definition definition = definitions[i];
for (Iterator iter1 = definition.getEPortTypes().iterator(); iter1.hasNext();) {
PortType portType = (PortType) iter1.next();
for (Iterator iter2 = portType.getOperations().iterator(); iter2.hasNext();) {
Operation operation = (Operation) iter2.next();
Fault fault = (Fault) operation.getFault(faultQName.getLocalPart());
if (fault != null) {
return fault.getEMessage();
}
}
}
}
// it does not exist in a WSDL files, check
// if it is declared in a throw activity
return getMessageFromThrow(faultQName);
}
protected Definition[] getDefinitions(String namespace) {
List<Definition> result = new ArrayList<Definition>();
List<Import> imports = getProcess().getImports();
if (imports != null) {
for (Import _import: imports) {
if (WSDLConstants.WSDL_NAMESPACE_URI.equals(_import.getImportType())) {
if (namespace.equals(_import.getNamespace())) {
result.add(WSDLImportHelper.getDefinition(_import));
}
}
}
}
return result.toArray(new Definition[result.size()]);
}
/**
* Given the fault qname, looks for the message type defined by
* a throw activity visible to this context.
*/
protected Message getMessageFromThrow(QName faultQName) {
Object container = getInput().eContainer().eContainer();
if (!(container instanceof Scope)) return null; // it might be an invoke so return null
Scope scope = (Scope) container;
for (Iterator<EObject> iter = scope.eAllContents(); iter.hasNext();) {
Object element = iter.next();
if (element instanceof Throw) {
Throw t = (Throw) element;
if (faultQName.equals(t.getFaultName()) && (t.getFaultVariable() != null)) {
return (t.getFaultVariable()).getMessageType();
}
}
}
return null;
}
protected boolean isEmptyMessageType(String newName) {
return Messages.FaultCatchNameSection_None_0.equals(newName) && builtinRadio.getSelection();
}
protected List<String> getBuiltinFaultNames() {
List<String> faultNames = new ArrayList<String>();
faultNames.add(Messages.FaultCatchNameSection_None_0);
faultNames.addAll(Arrays.asList(BPELConstants.standardFaults));
return faultNames;
}
protected boolean isBuiltinFault(String faultNamespace) {
boolean isBuiltin = BPELConstants.NAMESPACE.equals(faultNamespace);
if (faultNamespace == null) {
if (ModelHelper.getFaultName(getInput()) == null) isBuiltin = true;
}
return isBuiltin;
}
}