/*******************************************************************************
* 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 org.eclipse.bpel.common.ui.details.IDetailsAreaConstants;
import org.eclipse.bpel.common.ui.details.widgets.DecoratedLabel;
import org.eclipse.bpel.common.ui.details.widgets.StatusLabel2;
import org.eclipse.bpel.common.ui.flatui.FlatFormAttachment;
import org.eclipse.bpel.common.ui.flatui.FlatFormData;
import org.eclipse.bpel.model.BPELFactory;
import org.eclipse.bpel.model.Expression;
import org.eclipse.bpel.model.util.BPELConstants;
import org.eclipse.bpel.ui.BPELUIPlugin;
import org.eclipse.bpel.ui.Messages;
import org.eclipse.bpel.ui.commands.CompoundCommand;
import org.eclipse.bpel.ui.commands.SetCommand;
import org.eclipse.bpel.ui.details.providers.ExpressionEditorDescriptorContentProvider;
import org.eclipse.bpel.ui.expressions.IEditorConstants;
import org.eclipse.bpel.ui.expressions.IExpressionEditor;
import org.eclipse.bpel.ui.extensions.BPELUIRegistry;
import org.eclipse.bpel.ui.extensions.ExpressionEditorDescriptor;
import org.eclipse.bpel.ui.util.BPELUtil;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.gef.commands.Command;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
/**
* Base class with some shared behavior for details panes that edit an expression.
*
* NB: Nov 2nd, 2006
*
* The code used CComboViewer and CCombo to show the expression language drop down.
* There used to be a lot of code that dealt with refresh and selection disappearing in the
* CCombo to the point that the XPath editor was created and destroyed 14 times every time a
* object was selected in the process map that required this particular expression section.
*
* I debugged the code, I swear it was this bad.
*
* I had done some cleanup here to make it easier to understand because there is truly a little
* too much magic for this simple thing. So ...
*
* <ol>
* <li> The expression language is a Combo, wrapped in a ComboViewer.
* <li> The ComboViewer has a content provider which it will refresh every time a setInput is
* used on the ComboViewer. Any other refresh logic is not necessary.
* <li> The section is configured when the basicSetInput is called. Then the editor is picked,created, etc.
* <li> There is a general problem with refresh() method calls, .aboutToBeShown(), etc. many of them simply
* used to call refresh() which just destroyed and re-created the views.
*
* </ol>
*
* @author Michal Chmielewski (michal.chmielewski@oracle.com)
*
*/
public abstract class ExpressionSection extends TextSection {
protected String editorLanguage;
protected ComboViewer expressionLanguageViewer;
protected ExpressionComboContentProvider expressionComboContentProvider;
/** The editor area composite, it is used to display editors or the no-editor widgets in it */
protected Composite fEditorArea ;
// Pseudo-model object to represent no expression at all (in which case no editor
// is used).
protected static final Object NO_EXPRESSION = new Object();
// Pseudo-model object to represent the absence of an expression language within
// the expression (i.e. the expression language is inherited from the Process).
protected static final Object SAME_AS_PARENT = new Object();
/** The composite which holds the no-editor widgets */
protected Composite fNoEditorWidgets;
/** The parent composite, it owns the expression language combo and the editor area */
protected Composite fParentComposite;
protected Font boldFont;
protected String title;
protected Label titleLabel;
StackLayout fEditorAreaStackLayout;
Composite fEditorComposite;
protected StatusLabel2 expressionLanguageLabel;
/** The EMF structural feature that is this expression */
protected EStructuralFeature fStructuralFeature;
protected Button fCreateExpressionButton;
Combo expressionLanguageCombo;
protected static boolean objectsEqual(Object lhs, Object rhs) {
if (lhs == null) return (rhs == null);
return lhs.equals(rhs);
}
/**
* A content provider which (1) adds the NO_EXPRESSION and SAME_AS_PARENT elements,
* (2) ensures that the selected object is in the list, and (3) removes any
* elements from the list which are not supported (unless they happen to be
* the selected object at the moment--an error case).
*/
class ExpressionComboContentProvider extends ExpressionEditorDescriptorContentProvider {
Object selectedObject = SAME_AS_PARENT;
/**
* @see org.eclipse.bpel.ui.details.providers.AbstractContentProvider#getElements(java.lang.Object)
*/
@Override
public Object[] getElements(Object inputElement) {
Object[] descriptors = super.getElements(inputElement);
ArrayList<Object> result = new ArrayList<Object>(descriptors.length + 2);
if (isExpressionOptional() || selectedObject==NO_EXPRESSION) {
result.add(NO_EXPRESSION);
}
if (selectedObject==SAME_AS_PARENT || allowItem(SAME_AS_PARENT)) {
result.add(SAME_AS_PARENT);
}
for (Object descriptor : descriptors) {
if (objectsEqual(selectedObject, descriptor) || allowItem(descriptor)) {
result.add(descriptor);
}
}
if (!result.contains(selectedObject)) {
result.add(selectedObject);
}
return result.toArray();
}
/**
*
* @param element
* @return true if item is to be allowed, false otherwise.
*/
public boolean allowItem(Object element) {
String language = getEffectiveLanguage(getExpressionLanguage(element));
try {
IExpressionEditor exEditor = BPELUIRegistry.getInstance().getExpressionEditor(language);
return (exEditor == null)? false : isEditorSupported(exEditor);
} catch (CoreException e) {
BPELUIPlugin.log(e);
return false;
}
}
}
@Override
protected void addAllAdapters() {
super.addAllAdapters();
Expression e = getExprFromModel();
if (e != null) {
fAdapters[0].addToObject(e);
}
}
/**
* Get rid of the current editor.
* We do this when the Expression Language changes and we have to replace the editor with the right
* editor for the expression language.
*/
@Override
protected void disposeEditor() {
super.disposeEditor();
editorLanguage = null;
if (fEditorComposite != null) {
fEditorComposite.dispose();
fEditorComposite = null;
}
}
protected Object getDefaultBody (String newLanguage, String exprType ) {
IExpressionEditor ed = null;
try {
newLanguage = getEffectiveLanguage(newLanguage);
ed = BPELUIRegistry.getInstance().getExpressionEditor(newLanguage);
} catch (CoreException e) {
BPELUIPlugin.log(e);
return EMPTY_STRING;
}
// TODO: call supportsExpressionType in the right place
ed.setExpressionType(exprType);
ed.setModelObject( getInput() );
return ed.getDefaultContent() ;
}
protected void createTitleWidgets(Composite composite) {
FlatFormData data;
titleLabel = fWidgetFactory.createLabel(composite, title);
titleLabel.setFont(boldFont);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.top = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(100, 0);
titleLabel.setLayoutData(data);
}
protected void createExpressionLanguageWidgets(final Composite composite) {
FlatFormData data;
DecoratedLabel nameLabel = new DecoratedLabel(composite,SWT.LEFT);
fWidgetFactory.adapt(nameLabel);
nameLabel.setText( Messages.ExpressionSection_Expression_language_1);
expressionLanguageLabel = new StatusLabel2( nameLabel );
expressionLanguageCombo = new Combo (composite, SWT.FLAT | SWT.READ_ONLY );
fWidgetFactory.adapt(expressionLanguageCombo);
expressionLanguageViewer = new ComboViewer(expressionLanguageCombo);
data = new FlatFormData();
data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(nameLabel, STANDARD_LABEL_WIDTH_LRG));
data.right = new FlatFormAttachment(100, 0);
if (this.title != null) {
data.top = new FlatFormAttachment(this.titleLabel, IDetailsAreaConstants.VSPACE);
} else {
data.top = new FlatFormAttachment(0, 0);
}
expressionLanguageViewer.getControl().setLayoutData(data);
expressionLanguageViewer.setLabelProvider(new LabelProvider() {
@Override
public String getText(Object element) {
if (element == NO_EXPRESSION) {
return Messages.ExpressionSection_No_Expression_2;
}
if (element == SAME_AS_PARENT) {
String text = getBPELEditor().getProcess().getExpressionLanguage();
if (text == null) {
text = BPELConstants.XMLNS_XPATH_EXPRESSION_LANGUAGE;
}
ExpressionEditorDescriptor descriptor = BPELUIRegistry.getInstance().getExpressionEditorDescriptor(text);
if (descriptor != null) {
text = descriptor.getLabel();
}
return NLS.bind(Messages.ExpressionSection_Same_as_Process_1, (new Object[] { text }));
}
if (element instanceof String) {
return (String)element;
}
ExpressionEditorDescriptor descriptor = (ExpressionEditorDescriptor) element;
String text = descriptor.getLabel();
return (text != null) ? text : descriptor.getExpressionLanguage();
}
});
expressionComboContentProvider = new ExpressionComboContentProvider();
expressionLanguageViewer.setContentProvider(expressionComboContentProvider);
expressionLanguageViewer.setInput( SAME_AS_PARENT );
data = new FlatFormData();
data.left = new FlatFormAttachment(0, 0);
data.right = new FlatFormAttachment(expressionLanguageViewer.getControl(), -IDetailsAreaConstants.HSPACE);
data.top = new FlatFormAttachment(expressionLanguageViewer.getControl(), 0, SWT.CENTER);
expressionLanguageLabel.setLayoutData(data);
// Selection on the combo.
expressionLanguageCombo.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
updateFromSelection ( selectedExpressionLanguage() );
}
});
}
protected void updateFromSelection ( Object elm ) {
Command cmd;
if (elm == NO_EXPRESSION || elm == null ) {
cmd = new SetCommand(getExpressionTarget(), null, getStructuralFeature() );
} else {
String language = getExpressionLanguage(elm);
Expression exp = BPELFactory.eINSTANCE.createCondition();
exp.setExpressionLanguage(language);
Object newDefaultBody = getDefaultBody(language, getExpressionType() );
// Figure out what the new default value should be for this expression,
// and install it in the model. It is necessary to do this before we
// properly create the editor (which happens when we update widgets in
// response to the model change).
exp.setBody(newDefaultBody);
cmd = new SetCommand(getExpressionTarget(), getExpression4Target (exp), getStructuralFeature()) ;
}
getCommandFramework().execute( wrapInShowContextCommand(cmd) );
}
/**
* Return the currently selected expression language.
*
* @return the currently selected expression language
*/
protected Object selectedExpressionLanguage () {
IStructuredSelection selection = (IStructuredSelection) expressionLanguageViewer.getSelection();
return selection.getFirstElement();
}
/**
* This method is used by subclasses who need to select a language programmatically.
*
*/
protected void doChooseExpressionLanguage (Object model) {
Object selection = selectedExpressionLanguage();
if (selection == model) {
return ;
}
// By setting the selection on the combo box, we are kicking off a selection changed event.
// This is intentional, because we are emulating the a user interface command.
expressionLanguageViewer.setSelection(new StructuredSelection( model ), true);
updateFromSelection( selectedExpressionLanguage() );
}
protected void updateExpressionLanguageWidgets() {
Object model = NO_EXPRESSION;
if (getExprFromModel() != null) {
String language = getExpressionLanguageFromModel();
if (language == null) {
model = SAME_AS_PARENT;
} else {
model = BPELUIRegistry.getInstance().getExpressionEditorDescriptor(language);
if (model == null) {
model = language;
}
}
}
expressionLanguageViewer.setSelection( new StructuredSelection( model ), true );
// Reflect the model in the editor
updateEditor();
// Markers
updateMarkers();
}
/**
* When this method is called, the section has already been created.
*
* The widgets are available to be configured, however, the section may not be shown yet.
*
* The concept here is that we are reflecting the input selected in the UI. So the path that is taken
* by this code must not create any re-doable commands, just set the widgets to what they are supposed to
* be based on the model.
*/
@Override
protected void basicSetInput (EObject newInput) {
super.basicSetInput(newInput);
/** Figure out based in the input, what EMF structural feature we are setting */
setStructuralFeature ( getStructuralFeature (newInput) );
// A different input may have different expression language settings.
expressionLanguageViewer.refresh(true);
// Reveal the right selection in the widget.
updateExpressionLanguageWidgets();
}
protected void setStructuralFeature ( EStructuralFeature feature ) {
fStructuralFeature = feature;
}
/**
* Get the structural feature of this input object.
* This will be something like BPELPackage.eINSTANCE.getWait_Until()
*
* @param eObject
* @return the structural feature that we will be setting.
*/
protected EStructuralFeature getStructuralFeature ( EObject eObject ) {
return null;
}
/**
* Return the previously computed structural feature of the input object.
* @return
*/
protected EStructuralFeature getStructuralFeature () {
return fStructuralFeature;
}
protected boolean isExpressionOptional() {
return true;
}
protected String getExpressionType() {
return IEditorConstants.ET_ANY ;
}
/**
* The expression target is the target object on which we can execute
* the SetCommand(target,object,structural-feature).
*
* In most cases, it is just the input of the section. But in some cases
* the input if the section does not match the target, so sub-classes
* may override this method.
*
* @return
*/
protected EObject getExpressionTarget () {
return getInput();
}
/**
* Returns the expressionLanguage string underlying the given combo element. For
* cases other than NO_EXPRESSION, this is the proper value to store into the model.
*/
protected String getExpressionLanguage (Object comboElement) {
if (comboElement == NO_EXPRESSION || comboElement == SAME_AS_PARENT) {
return null;
}
String language = null;
if (comboElement instanceof ExpressionEditorDescriptor) {
language = ((ExpressionEditorDescriptor)comboElement).getExpressionLanguage();
} else if (comboElement instanceof String) {
language = (String)comboElement;
}
if (EMPTY_STRING.equals(language)) {
language = null;
}
return language;
}
/**
* Returns the expression language which will be in effect if this language is
* read from/stored into the model. (i.e. if language is null, the value is
* inherited from the process or the default, XPath).
*/
protected String getEffectiveLanguage(String language) {
if (language == null) {
language = getBPELEditor().getProcess().getExpressionLanguage();
if (language == null) {
language = BPELConstants.XMLNS_XPATH_EXPRESSION_LANGUAGE;
}
}
return language;
}
/**
* Return the actual namespace from the expression, or null if not set.
*/
protected String getExpressionLanguageFromModel() {
Expression expression = getExprFromModel();
if (expression == null) {
return null;
}
return expression.getExpressionLanguage();
}
protected Expression getExprFromModel() {
EObject target = getExpressionTarget();
if (target != null) {
Object result = target.eGet( getStructuralFeature() );
if (result instanceof Expression) {
return (Expression) result;
}
}
return null;
}
protected Expression getExpression4Target ( Expression expression ) {
return expression;
}
@Override
protected boolean isBodyAffected(Notification n) {
if (n.getOldValue() instanceof Expression ||
n.getNewValue() instanceof Expression ||
n.getNotifier() instanceof Expression) {
return true;
}
return n.getFeature() == getStructuralFeature();
}
@Override
protected Command newStoreToModelCommand (Object body) {
CompoundCommand result = new CompoundCommand();
Expression oldExp = getExprFromModel();
Expression exp = BPELFactory.eINSTANCE.createCondition();
// Don't set the language, because if the user has changed the
// language, a condition would already exist at this point.
if (oldExp != null) {
exp.setExpressionLanguage(oldExp.getExpressionLanguage());
}
exp.setBody(body);
result.add (new SetCommand(getExpressionTarget(), getExpression4Target(exp) , getStructuralFeature() ));
fEditor.addExtraStoreCommands (result);
return result;
}
/**
* Create the client area. This is just done once.
*/
@Override
protected void createClient (Composite parent) {
fParentComposite = createFlatFormComposite(parent);
if (this.title != null) {
createBoldFont(fParentComposite);
createTitleWidgets(fParentComposite);
}
createExpressionLanguageWidgets(fParentComposite);
FlatFormData data = new FlatFormData();
data.top = new FlatFormAttachment(expressionLanguageViewer.getControl(),IDetailsAreaConstants.VSPACE);
data.left = new FlatFormAttachment(0,0);
data.right = new FlatFormAttachment(100,0);
data.bottom = new FlatFormAttachment(100,0);
fEditorArea = fWidgetFactory.createComposite(fParentComposite);
fEditorAreaStackLayout = new StackLayout();
fEditorArea.setLayout( fEditorAreaStackLayout );
fEditorArea.setLayoutData(data);
fNoEditorWidgets = createNoEditorWidgets(fEditorArea);
fEditorAreaStackLayout.topControl = fNoEditorWidgets;
createChangeHelper();
}
protected Composite createNoEditorWidgets (Composite composite) {
return fWidgetFactory.createComposite(composite);
}
protected Composite createNoEditorWidgetsCreateComposite (Composite composite, String message, String buttonMessage ) {
FlatFormData ffdata;
Composite section = createFlatFormComposite(composite);
Label label = fWidgetFactory.createLabel(section,EMPTY_STRING, SWT.WRAP | SWT.READ_ONLY );
ffdata = new FlatFormData();
ffdata.left = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE );
ffdata.top = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE * 2);
ffdata.right = new FlatFormAttachment(100, 0);
label.setLayoutData(ffdata);
fCreateExpressionButton = fWidgetFactory.createButton(section, buttonMessage , SWT.PUSH);
ffdata = new FlatFormData();
ffdata.left = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE);
ffdata.top = new FlatFormAttachment(label, IDetailsAreaConstants.VSPACE * 2);
fCreateExpressionButton.setLayoutData(ffdata);
fCreateExpressionButton.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
doChooseExpressionLanguage(SAME_AS_PARENT);
}
public void widgetDefaultSelected(SelectionEvent e) { }
});
label.setText(message);
return section;
}
/**
* Create the editor.
*
*/
@Override
protected void createEditor (Composite parent) {
String language = getEffectiveLanguage(getExpressionLanguageFromModel());
try {
fEditor = BPELUIRegistry.getInstance().getExpressionEditor(language);
} catch (CoreException e) {
BPELUIPlugin.log(e);
return ;
}
editorLanguage = language;
fEditor.createControls(parent, getWidgetFactory());
fEditor.addListener(new IExpressionEditor.Listener() {
public void notifyChanged() {
if (!updating) { // && !isExecutingStoreCommand()) {
notifyEditorChanged();
}
}
public void focusOut() {
// If expression editor has lost focus then apply current changes
getCommandFramework().applyCurrentChange();
}
public void focusIn() {
// TODO Auto-generated method stub
}
});
}
/**
* We update the editor from the model. This is a model-to-ui operation.
*
*/
@Override
protected void updateEditor() {
Expression expr = getExprFromModel();
Control previousTop = fEditorAreaStackLayout.topControl;
if (expr == null) {
fEditorAreaStackLayout.topControl = fNoEditorWidgets;
} else {
String newLanguage = getEffectiveLanguage(getExpressionLanguageFromModel());
if ( newLanguage.equals(editorLanguage) == false || hasEditor() == false) {
// get rid of the old editor
// The "old" editorComposite will be buried in the stack layout
disposeEditor();
fEditorComposite = fWidgetFactory.createComposite(fEditorArea);
fEditorComposite.setLayout( new FillLayout() );
createEditor (fEditorComposite);
}
fEditorAreaStackLayout.topControl = fEditorComposite;
// we update our editor with the model, since something may have changed
// in it that needs to be reflected in the editor.
fEditor.setExpressionType( getExpressionType() );
// editor.setExpressionType(getExpressionType(), getExpressionContext());
fEditor.setModelObject(getInput());
// TODO: WTF ?
fEditor.setEditorContent( (String) expr.getBody());
fEditor.aboutToBeShown();
}
if ( previousTop != fEditorAreaStackLayout.topControl ) {
// Layout is necessary after swapping the top element in the stack layout
fEditorArea.layout(new Control[] { fEditorAreaStackLayout.topControl } );
}
}
/**
* This is used by the Expression Language combo to filter out editors that
* can't be used with the current type/context.
*/
protected boolean isEditorSupported(IExpressionEditor exEditor) {
return exEditor.supportsExpressionType( getExpressionType() );
}
/**
* Whether the marker use type is useful for this section.
*/
protected boolean isValidClientUseType (String useType) {
return false;
}
/**
* Answer if we have an editor visible.
*
* @return true if visible, false otherwise.
*/
public boolean hasEditor () {
return (fEditor != null && fEditorAreaStackLayout.topControl != fNoEditorWidgets) ;
}
private void createBoldFont (Composite parent) {
FontData[] data = parent.getDisplay().getSystemFont().getFontData();
FontData data0 = data[0];
data0.setStyle(SWT.BOLD);
boldFont = new Font(parent.getDisplay(), data0);
}
/** (non-Javadoc)
* @see org.eclipse.bpel.ui.properties.TextSection#dispose()
*/
@Override
public void dispose() {
if (boldFont != null) {
boldFont.dispose();
}
super.dispose();
}
@Override
protected void updateMarkers () {
expressionLanguageLabel.clear();
for(IMarker m : getMarkers(getInput())) {
if (expressionLanguageLabel.getControl().isDisposed() == false) {
expressionLanguageLabel.addStatus( BPELUtil.adapt(m, IStatus.class) );
} else {
new Throwable("FixMe: Why is update markers being called ?").printStackTrace();
}
}
}
// public void aboutToBeHidden() {
// super.aboutToBeHidden();
// if (expressionChangeHelper != null) {
// getCommandFramework().notifyChangeDone(expressionChangeHelper);
// }
// }
}