Example usage for org.eclipse.jface.databinding.swt SWTObservables observeText

List of usage examples for org.eclipse.jface.databinding.swt SWTObservables observeText

  1. HOME
  2. Java
  3. org.eclipse.jface
  4. org.eclipse.jface.databinding.swt.*
  5. SWTObservables
  6. observeText

Introduction

In this page you can find the example usage for org.eclipse.jface.databinding.swt SWTObservables observeText.

Prototype

@Deprecated
public static ISWTObservableValue observeText(Control control, int event)

Source Link

Document

Returns an observable observing the text attribute of the provided control.

Usage

From source file:org.bonitasoft.studio.connector.model.implementation.wizard.AbstractImplementationWizardPage.java

License:Open Source License

@Override
public void createControl(Composite parent) {

    context = new EMFDataBindingContext();
    if (pageSupport == null) {
        pageSupport = WizardPageSupport.create(this, context);
    }/* w  ww  .  j av a  2 s.co m*/

    Composite mainComposite = new Composite(parent, SWT.NONE);
    mainComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(3).margins(10, 10).create());

    final Label definitionIdLabel = new Label(mainComposite, SWT.NONE);
    definitionIdLabel.setText(Messages.implementationId + " *");
    definitionIdLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());

    final Composite idComposite = new Composite(mainComposite, SWT.NONE);
    idComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(2, 1).create());
    idComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(3).margins(0, 0).create());

    final Text idText = new Text(idComposite, SWT.BORDER);
    idText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

    UpdateValueStrategy idStrategy = new UpdateValueStrategy();
    idStrategy.setAfterGetValidator(new EmptyInputValidator(Messages.implementationId));
    idStrategy.setBeforeSetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            if (!FileUtil.isValidName(NamingUtils.toConnectorImplementationFilename(value.toString(),
                    implementation.getImplementationVersion(), true))) {
                return ValidationStatus.error(Messages.invalidFileName);
            }
            return Status.OK_STATUS;
        }
    });

    Label definitionVersionLabel = new Label(idComposite, SWT.NONE);
    definitionVersionLabel.setText(Messages.versionLabel + " *");
    definitionVersionLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());

    final Text versionText = new Text(idComposite, SWT.BORDER);
    versionText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

    UpdateValueStrategy versionStrategy = new UpdateValueStrategy();
    versionStrategy.setAfterGetValidator(new EmptyInputValidator(Messages.versionLabel));
    versionStrategy.setBeforeSetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            if (value.toString().contains(" ")) {
                return ValidationStatus.error("Whitespace is not allowed in version id");
            }
            if (!FileUtil.isValidName(NamingUtils.toConnectorImplementationFilename(
                    implementation.getImplementationId(), value.toString(), true))) {
                return ValidationStatus.error(Messages.invalidFileName);
            }
            return Status.OK_STATUS;
        }
    });

    final ISWTObservableValue observableIdText = SWTObservables.observeText(idText, SWT.Modify);
    final ISWTObservableValue observableVersionText = SWTObservables.observeText(versionText, SWT.Modify);
    final MultiValidator definitionValidator = new MultiValidator() {

        @Override
        protected IStatus validate() {
            if (observableIdText.getValue().toString().contains(" ")) {
                return ValidationStatus.error("Whitespace is not allowed in definition id");
            }
            String implID = NamingUtils.toConnectorImplementationFilename(
                    observableIdText.getValue().toString(), observableVersionText.getValue().toString(), false);
            for (ConnectorImplementation impl : existingImpl) {
                String existingId = NamingUtils.toConnectorImplementationFilename(impl.getImplementationId(),
                        impl.getImplementationVersion(), false);
                if (implID.equals(existingId)) {
                    return ValidationStatus.error(Messages.implementationAlreadyExists);
                }
            }
            return ValidationStatus.ok();
        }
    };

    context.addValidationStatusProvider(definitionValidator);
    context.bindValue(observableIdText,
            EMFObservables.observeValue(implementation,
                    ConnectorImplementationPackage.Literals.CONNECTOR_IMPLEMENTATION__IMPLEMENTATION_ID),
            idStrategy, null);
    context.bindValue(observableVersionText,
            EMFObservables.observeValue(implementation,
                    ConnectorImplementationPackage.Literals.CONNECTOR_IMPLEMENTATION__IMPLEMENTATION_VERSION),
            versionStrategy, null);

    Label descriptionLabel = new Label(mainComposite, SWT.NONE);
    descriptionLabel.setText(Messages.description);
    descriptionLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.TOP).create());

    final Text descriptionText = new Text(mainComposite, SWT.BORDER | SWT.MULTI | SWT.WRAP);
    descriptionText.setLayoutData(
            GridDataFactory.fillDefaults().grab(true, false).hint(SWT.DEFAULT, 50).span(2, 1).create());
    UpdateValueStrategy descStrategy = new UpdateValueStrategy();
    descStrategy.setBeforeSetValidator(new InputLengthValidator(Messages.description, 255));
    context.bindValue(SWTObservables.observeText(descriptionText, SWT.Modify),
            EMFObservables.observeValue(implementation,
                    ConnectorImplementationPackage.Literals.CONNECTOR_IMPLEMENTATION__DESCRIPTION),
            descStrategy, null);

    createClassAndPackageName(mainComposite);
    createDependenciesViewer(mainComposite);

    final MultiValidator defValidator = new MultiValidator() {

        @Override
        protected IStatus validate() {
            String className = (String) observeClassText.getValue();
            String packageName = (String) observePackageText.getValue();
            if (className != null && !className.isEmpty()) {
                if (!packageName.isEmpty()) {
                    packageName = packageName + ".";
                }
                final String qualifiedClassName = packageName + className;
                for (ConnectorImplementation impl : existingImpl) {
                    if (qualifiedClassName.equals(impl.getImplementationClassname())) {
                        return ValidationStatus.error(qualifiedClassName + " "
                                + Messages.bind(Messages.alreadyExistsForAnotherImplementation,
                                        NamingUtils.toConnectorImplementationFilename(
                                                impl.getImplementationId(), impl.getImplementationVersion(),
                                                false)));
                    }
                }
            }
            return ValidationStatus.ok();
        }
    };
    context.addValidationStatusProvider(defValidator);

    updateButtons(new StructuredSelection());

    setControl(mainComposite);
}

From source file:org.bonitasoft.studio.connector.model.implementation.wizard.AbstractImplementationWizardPage.java

License:Open Source License

protected void createClassAndPackageName(Composite mainComposite) {
    Label classNameLabel = new Label(mainComposite, SWT.NONE);
    classNameLabel.setText(Messages.classNameLabel + " *");
    classNameLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());

    final Text classNameText = new Text(mainComposite, SWT.BORDER);
    classNameText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(2, 1).create());

    final Label packageLabel = new Label(mainComposite, SWT.NONE);
    packageLabel.setText(Messages.packageName + " *");
    packageLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());

    final Text packageText = new Text(mainComposite, SWT.BORDER);
    packageText.setLayoutData(//from ww w .j  a va  2 s  .  co m
            GridDataFactory.swtDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).create());

    UpdateValueStrategy packageTargetToModel = new UpdateValueStrategy();
    packageTargetToModel.setConverter(new Converter(String.class, String.class) {

        @Override
        public Object convert(Object from) {
            if (from != null) {
                String packageName = from.toString();
                if (!packageName.isEmpty()) {
                    packageName = packageName + ".";
                }
                if (classNameText != null && !classNameText.isDisposed()) {
                    return packageName + classNameText.getText();
                }
            }
            return null;
        }
    });
    packageTargetToModel.setAfterGetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            return JavaConventions.validatePackageName(value.toString(), JavaCore.VERSION_1_6,
                    JavaCore.VERSION_1_6);
        }
    });

    UpdateValueStrategy packageModelToTarget = new UpdateValueStrategy();
    packageModelToTarget.setConverter(new Converter(String.class, String.class) {

        @Override
        public Object convert(Object from) {
            if (from != null) {
                String qualifiedClassname = from.toString();
                if (qualifiedClassname.indexOf(".") != -1) {
                    int i = qualifiedClassname.lastIndexOf(".");
                    return qualifiedClassname.subSequence(0, i);
                } else {
                    return "";
                }
            }
            return null;
        }
    });

    UpdateValueStrategy classTargetToModel = new UpdateValueStrategy();
    classTargetToModel.setConverter(new Converter(String.class, String.class) {

        @Override
        public Object convert(Object from) {
            if (from != null) {
                String className = from.toString();
                if (packageText != null && !packageText.isDisposed()) {
                    String packageName = packageText.getText().trim();
                    if (!packageName.isEmpty()) {
                        packageName = packageName + ".";
                    }
                    return packageName + className;
                }
            }
            return null;
        }
    });
    classTargetToModel.setAfterGetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            if (value == null || value.toString().isEmpty()) {
                return ValidationStatus.error(Messages.missingImplemenationClass);
            }
            return JavaConventions.validateClassFileName(value.toString() + ".class", JavaCore.VERSION_1_6,
                    JavaCore.VERSION_1_6);
        }
    });
    classTargetToModel.setBeforeSetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            if (implementation.getImplementationClassname() == null
                    || implementation.getImplementationClassname().toString().indexOf(".") == -1) {
                return JavaConventions.validatePackageName("", JavaCore.VERSION_1_6, JavaCore.VERSION_1_6);
            }
            return Status.OK_STATUS;
        }
    });

    UpdateValueStrategy classModelToTarget = new UpdateValueStrategy();
    classModelToTarget.setConverter(new Converter(String.class, String.class) {

        @Override
        public Object convert(Object from) {
            if (from != null) {
                String qualifiedClassname = from.toString();
                if (qualifiedClassname.indexOf(".") != -1) {
                    int i = qualifiedClassname.lastIndexOf(".");
                    return qualifiedClassname.subSequence(i + 1, qualifiedClassname.length());
                } else {
                    return qualifiedClassname;
                }
            }
            return null;
        }
    });

    observeClassText = SWTObservables.observeText(classNameText, SWT.Modify);
    observePackageText = SWTObservables.observeText(packageText, SWT.Modify);

    context.bindValue(observeClassText,
            EMFObservables.observeValue(implementation,
                    ConnectorImplementationPackage.Literals.CONNECTOR_IMPLEMENTATION__IMPLEMENTATION_CLASSNAME),
            classTargetToModel, classModelToTarget);
    context.bindValue(observePackageText,
            EMFObservables.observeValue(implementation,
                    ConnectorImplementationPackage.Literals.CONNECTOR_IMPLEMENTATION__IMPLEMENTATION_CLASSNAME),
            packageTargetToModel, packageModelToTarget);

    final Button browsePackagesButton = new Button(mainComposite, SWT.PUSH);
    browsePackagesButton.setText(Messages.browsePackages);
    browsePackagesButton.addListener(SWT.Selection, new Listener() {
        @Override
        public void handleEvent(Event event) {
            IPackageFragment selectedPackage = AbstractImplementationWizardPage.this.choosePackage();
            if (selectedPackage != null) {
                packageText.setText(selectedPackage.getElementName());
            }
        }
    });

}

From source file:org.bonitasoft.studio.connectors.expression.ConnectorOutputExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, ExpressionViewer expressionViewer) {
    this.inputExpression = inputExpression;
    Set<Output> input = new HashSet<Output>();
    IExpressionProvider provider = ExpressionEditorService.getInstance()
            .getExpressionProvider(ExpressionConstants.CONNECTOR_OUTPUT_TYPE);
    for (Expression e : provider.getExpressions(context)) {
        if (inputExpression.isReturnTypeFixed()) {
            if (e.getReturnType().equals(inputExpression.getReturnType())) {
                input.add((Output) e.getReferencedElements().get(0));
            }/*from  w w w  .  ja  v  a  2 s .  c om*/
        } else {
            input.add((Output) e.getReferencedElements().get(0));
        }
    }
    viewer.setInput(input);

    IObservableValue contentObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);
    IObservableValue nameObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__NAME);
    IObservableValue returnTypeObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__RETURN_TYPE);
    IObservableValue referenceObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__REFERENCED_ELEMENTS);

    UpdateValueStrategy selectionToName = new UpdateValueStrategy();

    IConverter nameConverter = new Converter(Output.class, String.class) {

        @Override
        public Object convert(Object output) {
            return ((Output) output).getName();
        }

    };
    selectionToName.setConverter(nameConverter);

    UpdateValueStrategy selectionToContent = new UpdateValueStrategy();
    IConverter contentConverter = new Converter(Output.class, String.class) {

        @Override
        public Object convert(Object output) {
            return ((Output) output).getName();
        }

    };
    selectionToContent.setConverter(contentConverter);

    UpdateValueStrategy selectionToReturnType = new UpdateValueStrategy();
    IConverter returnTypeConverter = new Converter(Output.class, String.class) {

        @Override
        public Object convert(Object output) {
            return ((Output) output).getType();
        }

    };
    selectionToReturnType.setConverter(returnTypeConverter);

    UpdateValueStrategy selectionToReferencedData = new UpdateValueStrategy();
    IConverter referenceConverter = new Converter(Output.class, List.class) {

        @Override
        public Object convert(Object output) {
            return Collections.singletonList(output);
        }

    };
    selectionToReferencedData.setConverter(referenceConverter);

    UpdateValueStrategy referencedDataToSelection = new UpdateValueStrategy();
    IConverter modelReferenceToTarget = new Converter(List.class, Output.class) {

        @Override
        public Object convert(Object outputList) {
            Output output = ((List<Output>) outputList).get(0);
            for (int i = 0; i < viewer.getTable().getItemCount(); i++) {
                Output out = (Output) viewer.getElementAt(i);
                if (out.getName().equals(output.getName()) && out.getType().equals(output.getType())) {
                    return out;
                }
            }
            return null;
        }

    };
    referencedDataToSelection.setConverter(modelReferenceToTarget);
    dataBindingContext.bindValue(SWTObservables.observeText(typeText, SWT.Modify), returnTypeObservable);
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), nameObservable,
            selectionToName, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), contentObservable,
            selectionToContent, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), returnTypeObservable,
            selectionToReturnType, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), referenceObservable,
            selectionToReferencedData, referencedDataToSelection);
}

From source file:org.bonitasoft.studio.connectors.ui.wizard.page.ExportConnectorWizardPage.java

License:Open Source License

@Override
public void createControl(Composite parent) {
    context = new EMFDataBindingContext();
    Composite composite = new Composite(parent, SWT.NONE);
    composite.setLayout(GridLayoutFactory.fillDefaults().numColumns(3).extendedMargins(10, 10, 10, 0).create());
    composite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());

    final Text serachBox = new Text(composite, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH);
    serachBox.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(3, 1).create());
    serachBox.setMessage(Messages.search);

    tableViewer = new TableViewer(composite, SWT.SINGLE | SWT.BORDER | SWT.FULL_SELECTION);
    tableViewer.getTable().setLayoutData(
            GridDataFactory.fillDefaults().grab(true, true).span(3, 1).hint(SWT.DEFAULT, 280).create());
    tableViewer.setContentProvider(contentProvider);
    tableViewer.setLabelProvider(labelProvider);
    tableViewer.addSelectionChangedListener(this);
    tableViewer.addDoubleClickListener(this);
    tableViewer.addFilter(new ViewerFilter() {

        @Override/*  w  w  w .jav  a2s  .com*/
        public boolean select(Viewer arg0, Object parentElement, Object element) {
            String search = serachBox.getText();
            return search == null || search.isEmpty()
                    || labelProvider.getText(element).toLowerCase().contains(search.toLowerCase());
        }
    });
    tableViewer.setInput(new Object());
    tableViewer.getTable().setFocus();

    serachBox.addModifyListener(new ModifyListener() {

        @Override
        public void modifyText(ModifyEvent e) {
            tableViewer.refresh();
        }
    });

    IValidator selectionValidator = new IValidator() {
        @Override
        public IStatus validate(Object value) {
            if (value == null) {
                return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID,
                        Messages.selectAConnectorImplWarning);
            }
            if (value instanceof ConnectorImplementation) {
                String id = ((ConnectorImplementation) value).getDefinitionId();
                String version = ((ConnectorImplementation) value).getDefinitionVersion();
                if (id == null || id.isEmpty()) {
                    return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID,
                            Messages.selectAValidConnectorImplWarning);
                }
                if (version == null || version.isEmpty()) {
                    return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID,
                            Messages.selectAValidConnectorImplWarning);
                }
                if (defStore.getDefinition(id, version, definitions) == null) {
                    return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID,
                            Messages.selectAValidConnectorImplWarning);
                }

                if (((ConnectorImplementation) value).getImplementationClassname() == null
                        || ((ConnectorImplementation) value).getImplementationClassname().isEmpty()) {
                    return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID,
                            Messages.selectAValidConnectorImplWarning);
                }
            }
            return Status.OK_STATUS;
        }
    };

    UpdateValueStrategy selectionStrategy = new UpdateValueStrategy();
    selectionStrategy.setBeforeSetValidator(selectionValidator);

    final Label inculeSourcesLabel = new Label(composite, SWT.NONE);
    inculeSourcesLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    inculeSourcesLabel.setText(Messages.inculeSourcesLabel);

    final Button includeSourceCheckbox = new Button(composite, SWT.CHECK);
    includeSourceCheckbox.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(2, 1).create());

    final Label addDependenciesLabel = new Label(composite, SWT.NONE);
    addDependenciesLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    addDependenciesLabel.setText(Messages.addDependencies);

    final Button addDependenciesCheckbox = new Button(composite, SWT.CHECK);
    addDependenciesCheckbox.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(2, 1).create());

    final Label destDirectoryLabel = new Label(composite, SWT.NONE);
    destDirectoryLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    destDirectoryLabel.setText(Messages.destinationLabel + " *");

    final Text destDirectoryText = new Text(composite, SWT.BORDER);
    destDirectoryText.setLayoutData(
            GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).create());

    Button destFileButton = new Button(composite, SWT.PUSH);
    destFileButton.setLayoutData(GridDataFactory.fillDefaults().hint(85, SWT.DEFAULT).create());
    destFileButton.setText(Messages.browsePackages);
    destFileButton.addListener(SWT.Selection, new Listener() {
        @Override
        public void handleEvent(Event event) {
            String defaultName = generateDefaultName();
            selectDirectory(destDirectoryText, defaultName);
        }
    });
    Label destFileNameLabel = new Label(composite, SWT.NONE);
    destFileNameLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    destFileNameLabel.setText(Messages.destFileNameLabel);
    destFileNameText = new Text(composite, SWT.BORDER);
    destFileNameText.setText(generateDefaultName());
    destFileNameText.setLayoutData(
            GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).create());
    UpdateValueStrategy pathStrategy = new UpdateValueStrategy();
    final EmptyInputValidator emptyValidator = new EmptyInputValidator(Messages.destinationLabel);
    pathStrategy.setBeforeSetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            IStatus status = emptyValidator.validate(value);
            if (!status.isOK()) {
                return status;
            }
            File target = new File((String) value);
            if (!target.exists()) {
                return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID, Messages.targetPathIsInvalid);
            }
            return Status.OK_STATUS;
        }
    });

    UpdateValueStrategy nameStrategy = new UpdateValueStrategy();
    nameStrategy.setBeforeSetValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            if (!value.toString().endsWith(".zip")) {
                return new Status(IStatus.ERROR, ConnectorPlugin.PLUGIN_ID, Messages.notAZipFile);
            }
            return Status.OK_STATUS;
        }
    });
    context.bindValue(ViewersObservables.observeSingleSelection(tableViewer),
            PojoProperties.value(ExportConnectorWizardPage.class, "selectedImplementation").observe(this),
            selectionStrategy, null);
    context.bindValue(SWTObservables.observeSelection(includeSourceCheckbox),
            PojoProperties.value(ExportConnectorWizardPage.class, "includeSources").observe(this));
    context.bindValue(SWTObservables.observeSelection(addDependenciesCheckbox),
            PojoProperties.value(ExportConnectorWizardPage.class, "addDependencies").observe(this));
    context.bindValue(SWTObservables.observeText(destDirectoryText, SWT.Modify),
            PojoProperties.value(ExportConnectorWizardPage.class, "destFilePath").observe(this), pathStrategy,
            null);
    context.bindValue(SWTObservables.observeText(destFileNameText, SWT.Modify),
            PojoProperties.value(ExportConnectorWizardPage.class, "destFileName").observe(this), nameStrategy,
            null);

    pageSupport = WizardPageSupport.create(this, context);

    setControl(composite);
}

From source file:org.bonitasoft.studio.connectors.ui.wizard.page.SelectEventConnectorNameAndDescWizardPage.java

License:Open Source License

protected void createConnectorFailsControls(Composite composite, EMFDataBindingContext context) {
    Label connectorFailsLabel = new Label(composite, SWT.NONE);
    connectorFailsLabel.setText(Messages.connectorCrashLabel);
    connectorFailsLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());

    if (connector.eContainingFeature() == ProcessPackage.Literals.PAGE_FLOW__PAGE_FLOW_CONNECTORS
            || container instanceof Form || container instanceof SubmitFormButton) {

        Label connectorFailText = new Label(composite, SWT.NONE);
        connectorFailText.setText(Messages.connectorFails_throwException);
        connectorFailText// w w  w.  j a  va2 s. c o m
                .setLayoutData(GridDataFactory.fillDefaults().align(SWT.BEGINNING, SWT.CENTER).create());

        connector.setThrowErrorEvent(false);
        connector.setIgnoreErrors(false);
        connector.setNamedError("");

    } else {

        final Combo connectorFailsCombo = new Combo(composite, SWT.READ_ONLY);
        connectorFailsCombo.add(Messages.connectorFails_crash);
        connectorFailsCombo.add(Messages.connectorFails_ignore);

        // Throw Event are not allowed in Connector in forms
        if (!(container instanceof Form || container instanceof SubmitFormButton)) {
            connectorFailsCombo.add(Messages.connectorFails_throwEvent);
        }

        UpdateValueStrategy ignoreEventStrategyTarget = new UpdateValueStrategy();
        ignoreEventStrategyTarget.setConverter(new Converter(String.class, Boolean.class) {

            @Override
            public Object convert(Object from) {
                if (from != null) {
                    return from.toString().equals(Messages.connectorFails_ignore);
                }
                return Boolean.FALSE;
            }
        });
        UpdateValueStrategy ignoreEventStrategyModel = new UpdateValueStrategy();
        ignoreEventStrategyModel.setConverter(new Converter(Boolean.class, String.class) {

            @Override
            public Object convert(Object from) {
                if ((Boolean) from) {
                    return Messages.connectorFails_ignore;
                } else if (connector.isThrowErrorEvent()) {
                    return Messages.connectorFails_throwEvent;
                }
                return Messages.connectorFails_crash;
            }
        });

        context.bindValue(WidgetProperties.text().observe(connectorFailsCombo),
                EMFObservables.observeValue(connector, ProcessPackage.Literals.CONNECTOR__IGNORE_ERRORS),
                ignoreEventStrategyTarget, ignoreEventStrategyModel);

        UpdateValueStrategy throwEventStrategyTarget = new UpdateValueStrategy();
        throwEventStrategyTarget.setConverter(new Converter(String.class, Boolean.class) {

            @Override
            public Object convert(Object from) {
                if (from != null) {
                    return from.toString().equals(Messages.connectorFails_throwEvent);
                }
                return Boolean.FALSE;
            }
        });

        UpdateValueStrategy throwEventStrategyModel = new UpdateValueStrategy();
        throwEventStrategyModel.setConverter(new Converter(Boolean.class, String.class) {

            @Override
            public Object convert(Object from) {
                if ((Boolean) from) {
                    return Messages.connectorFails_throwEvent;
                } else if (connector.isIgnoreErrors()) {
                    return Messages.connectorFails_ignore;
                }
                return Messages.connectorFails_crash;
            }
        });
        context.bindValue(WidgetProperties.text().observe(connectorFailsCombo),
                EMFObservables.observeValue(connector, ProcessPackage.Literals.CONNECTOR__THROW_ERROR_EVENT),
                throwEventStrategyTarget, throwEventStrategyModel);

        Label namedErrorEvent = new Label(composite, SWT.NONE);
        namedErrorEvent.setText(Messages.connectorFails_namedError);
        namedErrorEvent.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());

        final Text namedErrorText = new Text(composite, SWT.BORDER);
        namedErrorText.setTextLimit(255);
        namedErrorText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

        UpdateValueStrategy enableNamedErrorStrategyTarget = new UpdateValueStrategy();
        enableNamedErrorStrategyTarget.setConverter(new Converter(String.class, Boolean.class) {

            @Override
            public Object convert(Object from) {
                if (from != null) {
                    return from.toString().equals(Messages.connectorFails_throwEvent);
                }
                return Boolean.FALSE;
            }
        });

        context.bindValue(SWTObservables.observeText(namedErrorText, SWT.Modify),
                EMFObservables.observeValue(connector, ProcessPackage.Literals.CONNECTOR__NAMED_ERROR));
        namedErrorText.setEnabled(connector.isThrowErrorEvent());
        context.bindValue(WidgetProperties.text().observe(connectorFailsCombo),
                SWTObservables.observeEnabled(namedErrorText), enableNamedErrorStrategyTarget,
                new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));

    }
}

From source file:org.bonitasoft.studio.contract.ui.expression.ContractInputExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(final EMFDataBindingContext dataBindingContext, final EObject context,
        final Expression inputExpression, final ViewerFilter[] filters,
        final ExpressionViewer expressionViewer) {
    editorInputExpression = inputExpression;
    updateViewerInput(context);// ww w.  j  a va 2 s  .  c  o m

    final IObservableValue contentObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);
    final IObservableValue nameObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__NAME);
    final IObservableValue returnTypeObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__RETURN_TYPE);
    final IObservableValue referenceObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__REFERENCED_ELEMENTS);

    final IViewerObservableValue observeSingleSelection = ViewersObservables.observeSingleSelection(viewer);
    dataBindingContext.bindValue(observeSingleSelection,
            EMFObservables.observeValue(inputExpression, ExpressionPackage.Literals.EXPRESSION__TYPE),
            selectionToTypeStrategy(), new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));

    dataBindingContext.bindValue(observeSingleSelection, nameObservable, selectionToInputNameStrategy(),
            new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(observeSingleSelection, contentObservable, selectionToInputNameStrategy(),
            new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(observeSingleSelection, returnTypeObservable, selectionToReturnTypeStrategy(),
            new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(observeSingleSelection, referenceObservable,
            selectionToContractInputStrategy(), contractInputToSelectionStrategy());
    dataBindingContext.bindValue(SWTObservables.observeText(typeText, SWT.Modify), returnTypeObservable);
}

From source file:org.bonitasoft.studio.contract.ui.wizard.CreateContractInputFromBusinessObjectWizardPage.java

License:Open Source License

private void createRootNameControl(final EMFDataBindingContext dbc, final Composite composite) {
    final Composite rootNameComposite = new Composite(composite, SWT.NONE);
    rootNameComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(3).margins(10, 10).create());
    rootNameComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
    final Label label = new Label(rootNameComposite, SWT.NONE);
    label.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    label.setText(Messages.rootContractInputName);
    final Text prefixText = new Text(rootNameComposite, SWT.BORDER);
    prefixText.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
    final Label typeLabel = new Label(rootNameComposite, SWT.NONE);
    typeLabel.setText(Messages.inputOfType);
    final IObservableValue prefixObservable = PojoObservables.observeValue(this, "rootName");

    dbc.bindValue(prefixObservable,/*from   w w  w .  ja v a  2s  . c  o  m*/
            EMFObservables.observeDetailValue(Realm.getDefault(), selectedDataObservable,
                    ProcessPackage.Literals.ELEMENT__NAME),
            neverUpdateValueStrategy().create(),
            updateValueStrategy().withConverter(dataNameToRootContractInputName()).create());
    dbc.bindValue(
            SWTObservables.observeText(prefixText, SWT.Modify), prefixObservable, updateValueStrategy()
                    .withValidator(uniqueValidator().onProperty("name").in(contract.getInputs())).create(),
            null);
    dbc.bindValue(rootNameObservable, prefixObservable);
}

From source file:org.bonitasoft.studio.data.provider.DataExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, final ExpressionViewer expressionViewer) {

    final EObject finalContext = context;
    if (context instanceof Widget) {
        if (ModelHelper.getPageFlow((Widget) context) instanceof Pool) {
            addExpressionButton.setEnabled(false);
        }/*from   w  w  w  .ja  v a  2  s.c om*/
    }
    final ViewerFilter[] finalFilters = filters;
    addExpressionButton.addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent e) {
            try {
                expressionButtonListener(finalContext, expressionViewer, finalFilters);
            } catch (CoreException e1) {
                BonitaStudioLog.error(e1);
            }
        }
    });

    editorInputExpression = inputExpression;
    fillViewerData(context, filters);

    IObservableValue contentObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);
    IObservableValue nameObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__NAME);
    returnTypeObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__RETURN_TYPE);
    IObservableValue referenceObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__REFERENCED_ELEMENTS);

    UpdateValueStrategy selectionToName = new UpdateValueStrategy();
    IConverter nameConverter = new Converter(Data.class, String.class) {

        @Override
        public Object convert(Object data) {
            return ((Data) data).getName();
        }

    };
    selectionToName.setConverter(nameConverter);

    UpdateValueStrategy selectionToContent = new UpdateValueStrategy();
    IConverter contentConverter = new Converter(Data.class, String.class) {

        @Override
        public Object convert(Object data) {
            return ((Data) data).getName();
        }

    };
    selectionToContent.setConverter(contentConverter);

    UpdateValueStrategy selectionToReturnType = new UpdateValueStrategy();
    IConverter returnTypeConverter = new Converter(Data.class, String.class) {

        @Override
        public Object convert(Object data) {
            return org.bonitasoft.studio.common.DataUtil.getTechnicalTypeFor((Data) data);
        }

    };
    selectionToReturnType.setConverter(returnTypeConverter);

    UpdateValueStrategy selectionToReferencedData = new UpdateValueStrategy();
    IConverter referenceConverter = new Converter(Data.class, List.class) {

        @Override
        public Object convert(Object data) {
            if (data != null) {
                return Collections.singletonList(data);
            } else {
                return Collections.emptyList();
            }
        }

    };
    selectionToReferencedData.setConverter(referenceConverter);

    UpdateValueStrategy referencedDataToSelection = new UpdateValueStrategy();
    IConverter referencetoDataConverter = new Converter(List.class, Data.class) {

        @Override
        public Object convert(Object dataList) {
            Data d = ((List<Data>) dataList).get(0);
            Collection<Data> inputData = (Collection<Data>) viewer.getInput();
            for (Data data : inputData) {
                if (data.getName().equals(d.getName())
                        && data.getDataType().getName().equals(d.getDataType().getName())) {
                    return data;
                }
            }
            return null;
        }

    };
    referencedDataToSelection.setConverter(referencetoDataConverter);

    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), nameObservable,
            selectionToName, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), contentObservable,
            selectionToContent, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), returnTypeObservable,
            selectionToReturnType, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), referenceObservable,
            selectionToReferencedData, referencedDataToSelection);
    dataBindingContext.bindValue(SWTObservables.observeText(typeText, SWT.Modify), returnTypeObservable);

    if (context instanceof DateFormField) {

        final ControlDecoration cd = new ControlDecoration(typeText, SWT.TOP | SWT.LEFT);
        // cd.setImage(Pics.getImage(PicsConstants.error)) ;
        cd.setImage(PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJS_WARN_TSK));
        cd.setDescriptionText("It is recommanded to use Return type ad String or Date for Date Widget");
        cd.setShowOnlyOnFocus(false);
        if (typeText.getText().equals(Date.class.getName())
                || typeText.getText().equals(String.class.getName())) {
            cd.hide();
        } else {
            cd.show();
        }

        returnTypeObservable.addValueChangeListener(new IValueChangeListener() {

            @Override
            public void handleValueChange(ValueChangeEvent event) {
                if (typeText.getText().equals(Date.class.getName())
                        || typeText.getText().equals(String.class.getName())) {
                    cd.hide();
                } else {
                    cd.show();
                }

            }
        });

    }

}

From source file:org.bonitasoft.studio.data.provider.DocumentExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, ExpressionViewer expressionViewer) {
    editorInputExpression = inputExpression;
    fillViewerDocument(context, filters);

    IObservableValue contentObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);
    IObservableValue nameObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__NAME);
    returnTypeObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__RETURN_TYPE);
    IObservableValue referenceObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__REFERENCED_ELEMENTS);

    UpdateValueStrategy selectionToName = new UpdateValueStrategy();
    IConverter nameConverter = new Converter(Data.class, String.class) {

        @Override/*  w w  w. j  ava2  s.c o  m*/
        public Object convert(Object data) {
            return ((Data) data).getName();
        }

    };
    selectionToName.setConverter(nameConverter);

    UpdateValueStrategy selectionToContent = new UpdateValueStrategy();
    IConverter contentConverter = new Converter(Data.class, String.class) {

        @Override
        public Object convert(Object document) {
            return ((Document) document).getName();
        }

    };
    selectionToContent.setConverter(contentConverter);

    UpdateValueStrategy selectionToReturnType = new UpdateValueStrategy();
    IConverter returnTypeConverter = new Converter(Document.class, String.class) {

        @Override
        public Object convert(Object data) {
            return String.class.getName();
        }

    };
    selectionToReturnType.setConverter(returnTypeConverter);

    UpdateValueStrategy selectionToReferencedData = new UpdateValueStrategy();
    IConverter referenceConverter = new Converter(Document.class, List.class) {

        @Override
        public Object convert(Object document) {
            if (document != null) {
                return Collections.singletonList(document);
            } else {
                return Collections.emptyList();
            }
        }

    };
    selectionToReferencedData.setConverter(referenceConverter);

    UpdateValueStrategy referencedDataToSelection = new UpdateValueStrategy();
    IConverter referencetoDataConverter = new Converter(List.class, Document.class) {

        @Override
        public Object convert(Object dataList) {
            Document d = ((List<Document>) dataList).get(0);
            Collection<Document> inputDocs = (Collection<Document>) viewer.getInput();
            for (Document doc : inputDocs) {
                if (doc.getName().equals(d.getName())) {
                    return doc;
                }
            }
            return null;
        }

    };
    referencedDataToSelection.setConverter(referencetoDataConverter);

    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), nameObservable,
            selectionToName, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), contentObservable,
            selectionToContent, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), returnTypeObservable,
            selectionToReturnType, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), referenceObservable,
            selectionToReferencedData, referencedDataToSelection);
    dataBindingContext.bindValue(SWTObservables.observeText(typeText, SWT.Modify), returnTypeObservable);
}

From source file:org.bonitasoft.studio.data.provider.JavaExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, ExpressionViewer expressionViewer) {

    editorInputExpression = inputExpression;
    setContentProvider(new PojoBrowserContentProvider());
    javaTreeviewer.setContentProvider(getContentProvider());

    Set<Data> input = new HashSet<Data>();
    IExpressionProvider provider = ExpressionEditorService.getInstance()
            .getExpressionProvider(ExpressionConstants.VARIABLE_TYPE);
    for (Expression e : provider.getExpressions(context)) {
        Data data = (Data) e.getReferencedElements().get(0);
        if (data instanceof JavaObjectData || data.isMultiple()) {
            input.add(data);/*from   ww  w. jav  a2s. c  o m*/
        }
    }
    viewer.setInput(input);

    IObservableValue contentObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);
    IObservableValue nameObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__NAME);
    final IObservableValue returnTypeObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__RETURN_TYPE);
    IObservableValue referenceObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__REFERENCED_ELEMENTS);

    UpdateValueStrategy selectionToName = new UpdateValueStrategy();
    IConverter nameConverter = new Converter(Data.class, String.class) {

        @Override
        public Object convert(Object data) {
            if (data instanceof Data) {
                return ((Data) data).getName() + " - " + ((JavaObjectData) data).getClassName() + "#"
                        + editorInputExpression.getContent();
            } else if (data instanceof IMethod) {
                final JavaObjectData data2 = (JavaObjectData) editorInputExpression.getReferencedElements()
                        .get(0);
                return data2.getName() + " - " + data2.getClassName() + "#" + ((IMethod) data).getElementName();
            }
            return null;
        }

    };
    selectionToName.setConverter(nameConverter);

    UpdateValueStrategy selectionToContent = new UpdateValueStrategy();
    IConverter contentConverter = new Converter(Object.class, String.class) {

        @Override
        public Object convert(Object value) {
            if (value instanceof IMethod) {
                return ((IMethod) value).getElementName();
            }
            Object selection = ((IStructuredSelection) viewer.getSelection()).getFirstElement();
            if (selection instanceof Data) {
                return ((Data) selection).getName();
            }
            return null;
        }

    };
    selectionToContent.setConverter(contentConverter);

    UpdateValueStrategy methodToSelection = new UpdateValueStrategy();
    IConverter methodToSelectionConverter = new Converter(String.class, IMethod.class) {

        @Override
        public Object convert(Object methodName) {
            IType type = ((PojoBrowserContentProvider) getContentProvider()).getType();
            if (type != null) {
                try {
                    for (IMethod method : type.getMethods()) {
                        if (method.getElementName().equals(methodName)) {
                            return method;
                        }
                    }
                } catch (JavaModelException e) {

                }
            }
            return null;
        }

    };
    methodToSelection.setConverter(methodToSelectionConverter);

    UpdateValueStrategy selectionToReturnType = new UpdateValueStrategy();
    IConverter returnTypeConverter = new Converter(IType.class, String.class) {

        @Override
        public Object convert(Object iType) {
            if (!editorInputExpression.isReturnTypeFixed()) {
                if (iType instanceof IMethod) {
                    String qualifiedType = Object.class.getName();
                    try {
                        qualifiedType = JavaModelUtil.getResolvedTypeName(
                                Signature.getTypeErasure(((IMethod) iType).getReturnType()),
                                ((IMethod) iType).getDeclaringType());
                        if ("int".equals(qualifiedType)) {
                            qualifiedType = Integer.class.getName();
                        } else if ("boolean".equals(qualifiedType)) {
                            qualifiedType = Boolean.class.getName();
                        } else if ("long".equals(qualifiedType)) {
                            qualifiedType = Long.class.getName();
                        } else if ("float".equals(qualifiedType)) {
                            qualifiedType = Float.class.getName();
                        } else if ("double".equals(qualifiedType)) {
                            qualifiedType = Double.class.getName();
                        } else if ("short".equals(qualifiedType)) {
                            qualifiedType = Short.class.getName();
                        } else if ("byte".equals(qualifiedType)) {
                            qualifiedType = Byte.class.getName();
                        } else if ("E".equals(qualifiedType)) {
                            qualifiedType = Object.class.getName();
                        } else if ("V".equals(qualifiedType)) {
                            qualifiedType = Object.class.getName();
                        }
                    } catch (Exception e) {
                        BonitaStudioLog.error(e);
                    }
                    return qualifiedType;
                } else if (iType instanceof IType) {
                    return ((IType) iType).getFullyQualifiedName();
                }
            } else {
                return returnTypeObservable.getValue();
            }
            return null;
        }

    };
    selectionToReturnType.setConverter(returnTypeConverter);

    UpdateValueStrategy selectionToReferencedData = new UpdateValueStrategy();
    IConverter referenceConverter = new Converter(Data.class, List.class) {

        @Override
        public Object convert(Object data) {
            if (data != null) {
                return Collections.singletonList(data);
            } else {
                return Collections.emptyList();
            }
        }

    };
    selectionToReferencedData.setConverter(referenceConverter);

    UpdateValueStrategy referencedDataToSelection = new UpdateValueStrategy();
    IConverter referencetoDataConverter = new Converter(List.class, Data.class) {

        @Override
        public Object convert(Object dataList) {
            Data d = ((List<Data>) dataList).get(0);
            Collection<Data> inputData = (Collection<Data>) viewer.getInput();
            for (Data data : inputData) {
                if (data.getName().equals(d.getName())
                        && data.getDataType().getName().equals(d.getDataType().getName())) {
                    return data;
                }
            }
            return null;
        }

    };
    referencedDataToSelection.setConverter(referencetoDataConverter);
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), referenceObservable,
            selectionToReferencedData, referencedDataToSelection);
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), nameObservable,
            selectionToName, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(javaTreeviewer), nameObservable,
            selectionToName, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(javaTreeviewer), contentObservable,
            selectionToContent, methodToSelection);
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(javaTreeviewer),
            returnTypeObservable, selectionToReturnType,
            new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));
    dataBindingContext.bindValue(SWTObservables.observeText(typeText, SWT.Modify), returnTypeObservable);
}