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

List of usage examples for org.eclipse.jface.databinding.swt SWTObservables 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.data.ui.wizard.DataWizardPage.java

License:Open Source License

protected void bindNameAndDescription() {
    final UpdateValueStrategy nameStrategy = new UpdateValueStrategy();
    nameStrategy.setAfterGetValidator(new InputLengthValidator(Messages.name, 50));
    nameStrategy.setBeforeSetValidator(new IValidator() {

        @Override// w w  w.j av  a 2  s  .c o  m
        public IStatus validate(final Object value) {
            /* Search to check at the same level and under */
            for (final EStructuralFeature featureToCheck : featureToCheckForUniqueID) {
                for (final Object object : (List<?>) container.eGet(featureToCheck)) {
                    if (object instanceof Data) {
                        final Data otherData = (Data) object;
                        final Data originalData = ((DataWizard) getWizard()).getOriginalData();
                        if (!otherData.equals(originalData) && value.toString().equals(otherData.getName())) {
                            return new Status(IStatus.ERROR, DataPlugin.PLUGIN_ID, Messages.dataAlreadyExist);
                        }
                    }
                }
            }

            /* Search above level */
            List<Data> allData = null;
            if (container instanceof AbstractProcess) {
                allData = ModelHelper.getAllItemsOfType(ModelHelper.getParentProcess(container),
                        ProcessPackage.Literals.DATA);
            } else {
                //    allData = ModelHelper.getAccessibleData(container, true);
                allData = getAllAccessibleDatas(container);
            }
            for (final Data object : allData) {
                if (object instanceof Data && !(object.eContainer() instanceof Expression)) {
                    final Data otherData = (Data) object;
                    final Data originalData = ((DataWizard) getWizard()).getOriginalData();
                    if (!otherData.equals(originalData) && value.toString().equals(otherData.getName())) {
                        return new Status(IStatus.ERROR, DataPlugin.PLUGIN_ID, Messages.dataAlreadyExist);
                    }
                }
            }

            return new GroovyReferenceValidator(Messages.name).validate(value);
        }

        private List<Data> getAllAccessibleDatas(EObject container) {
            List<Data> allDatas = ModelHelper.getAccessibleData(container, true);
            for (Object o : ModelHelper.getAllItemsOfType(container, ProcessPackage.Literals.DATA)) {
                if (o instanceof Data) {
                    if (!allDatas.contains(o)) {
                        allDatas.add((Data) o);
                    }
                }
            }

            return allDatas;
        }
    });

    UpdateValueStrategy descTargetToModel = new UpdateValueStrategy();
    descTargetToModel.setAfterGetValidator(new InputLengthValidator(Messages.dataDescriptionLabel, 255));
    String previousName = null;
    if (nameText != null && !nameText.isDisposed() && nameText.getText() != null) {
        previousName = nameText.getText();
    }
    ISWTObservableValue observeText = SWTObservables.observeText(nameText, SWT.Modify);
    emfDatabindingContext.bindValue(observeText,
            EMFObservables.observeValue(data, ProcessPackage.Literals.ELEMENT__NAME), nameStrategy, null);
    emfDatabindingContext.bindValue(SWTObservables.observeText(descriptionText, SWT.Modify),
            EMFObservables.observeValue(data, ProcessPackage.Literals.ELEMENT__DOCUMENTATION),
            descTargetToModel, null);
    if (previousName != null && !previousName.isEmpty()) {
        observeText.setValue(previousName);
    }
}

From source file:org.bonitasoft.studio.data.ui.wizard.DataWizardPage.java

License:Open Source License

protected void bindJavaClassText() {
    if (classText != null && !classText.isDisposed()) {
        final UpdateValueStrategy classNameStrategy = new UpdateValueStrategy();
        classNameStrategy.setBeforeSetValidator(new IValidator() {

            @Override//  w w  w. j a  v  a2 s  .c  o  m
            public IStatus validate(final Object value) {
                if (value == null || value.toString().isEmpty()) {
                    return new Status(IStatus.ERROR, DataPlugin.PLUGIN_ID, Messages.emptyClassName);
                }
                IType type = null;
                try {
                    type = RepositoryManager.getInstance().getCurrentRepository().getJavaProject()
                            .findType(value.toString());
                } catch (final JavaModelException e) {
                }
                if (type == null) {
                    return new Status(IStatus.WARNING, DataPlugin.PLUGIN_ID,
                            NLS.bind(Messages.classNotFound, value.toString()));
                }
                return Status.OK_STATUS;
            }
        });
        emfDatabindingContext.bindValue(SWTObservables.observeText(classText, SWT.Modify),
                EMFObservables.observeValue(data, ProcessPackage.Literals.JAVA_OBJECT_DATA__CLASS_NAME),
                classNameStrategy, null);
    }
}

From source file:org.bonitasoft.studio.designer.ui.property.section.control.URLMappingComposite.java

License:Open Source License

public void doBindControl(final DataBindingContext context, final IObservableValue formMappingObservable) {
    context.bindValue(SWTObservables.observeText(urlText, SWT.Modify),
            CustomEMFEditObservables.observeDetailValue(Realm.getDefault(), formMappingObservable,
                    ProcessPackage.Literals.FORM_MAPPING__URL));
    doBindInfo(context, formMappingObservable);
}

From source file:org.bonitasoft.studio.document.core.expression.DocumentExpressionEditor.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;
    fillViewerDocument(context, filters);

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

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

        @Override// w  w  w. j  a v  a2s  .  co m
        public Object convert(final Object data) {
            return ((Data) data).getName();
        }

    };
    selectionToName.setConverter(nameConverter);

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

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

    };
    selectionToContent.setConverter(contentConverter);

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

        @Override
        public Object convert(final Object data) {
            if (data instanceof Document) {
                if (((Document) data).isMultiple()) {
                    return List.class.getName();
                } else {
                    return String.class.getName();
                }
            }
            return String.class.getName();
        }
    };
    selectionToReturnType.setConverter(returnTypeConverter);

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

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

    };
    selectionToReferencedData.setConverter(referenceConverter);

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

        @Override
        public Object convert(final Object dataList) {
            final Document d = ((List<Document>) dataList).get(0);
            final Collection<Document> inputDocs = (Collection<Document>) viewer.getInput();
            for (final 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.document.ui.control.DocumentDescriptionComposite.java

License:Open Source License

public void bindControl(final Document document, final EMFDataBindingContext emfDataBindingContext) {
    checkArgument(document != null);// w  w w. j a  v  a2 s  .  c om
    checkArgument(emfDataBindingContext != null);
    emfDataBindingContext.bindValue(SWTObservables.observeText(getText(), SWT.Modify),
            EMFObservables.observeValue(document, ProcessPackage.Literals.ELEMENT__DOCUMENTATION));
}

From source file:org.bonitasoft.studio.document.ui.control.DocumentNameComposite.java

License:Open Source License

public void bindControl(final Document document, final EObject context,
        final EMFDataBindingContext emfDataBindingContext) {
    checkArgument(document != null);/*  w ww . j  a va  2s . co  m*/
    checkArgument(context != null);
    checkArgument(emfDataBindingContext != null);
    emfDataBindingContext
            .bindValue(SWTObservables.observeText(documentNameText, SWT.Modify),
                    EMFObservables.observeValue(document, ProcessPackage.Literals.ELEMENT__NAME),
                    updateValueStrategy().withValidator(multiValidator()
                            .addValidator(maxLengthValidator(Messages.name, NAME_MAX_LENGTH))
                            .addValidator(groovyReferenceValidator(Messages.name))
                            .addValidator(uniqueValidator().in(processDocuments(context, document.getName()))
                                    .onProperty(ProcessPackage.Literals.ELEMENT__NAME.getName())))
                            .create(),
                    null);
}

From source file:org.bonitasoft.studio.expression.editor.constant.ConstantExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, ExpressionViewer expressionViewer) {
    this.inputExpression = inputExpression;
    IObservableValue contentModelObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);
    IObservableValue returnTypeModelObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__RETURN_TYPE);

    dataBindingContext.bindValue(SWTObservables.observeText(valueText, SWT.Modify), contentModelObservable);
    UpdateValueStrategy targetToModel = new UpdateValueStrategy();
    targetToModel.setAfterConvertValidator(new IValidator() {

        @Override/*from ww  w . j a  v a 2s  .com*/
        public IStatus validate(Object value) {
            if (value == null || value.toString().isEmpty()) {
                return ValidationStatus.error(Messages.returnTypeIsMandatory);
            }
            return ValidationStatus.ok();
        }
    });
    ControlDecorationSupport
            .create(dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(typeCombo),
                    returnTypeModelObservable, targetToModel, null), SWT.LEFT);
    typeCombo.getCombo().setEnabled(!inputExpression.isReturnTypeFixed());

}

From source file:org.bonitasoft.studio.expression.editor.formfield.FormFieldExpressionEditor.java

License:Open Source License

public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, ExpressionViewer expressionViewer) {
    this.inputExpression = inputExpression;
    Set<Widget> input = new HashSet<Widget>();
    IExpressionProvider provider = ExpressionEditorService.getInstance()
            .getExpressionProvider(ExpressionConstants.FORM_FIELD_TYPE);
    final Set<Expression> filteredExpressions = new HashSet<Expression>();
    final Set<Expression> expressions = provider.getExpressions(context);
    if (expressions != null) {
        filteredExpressions.addAll(expressions);
        if (context != null && filters != null) {
            for (final Expression exp : expressions) {
                for (final ViewerFilter filter : filters) {
                    if (filter != null && !filter.select(viewer, context, exp)) {
                        filteredExpressions.remove(exp);
                    }/*from w  w w .j  av a 2  s .c  o  m*/
                }
            }
        }
    }
    Set<String> widgetName = new HashSet<String>();
    for (Expression e : filteredExpressions) {
        Widget widget = (Widget) e.getReferencedElements().get(0);
        if (inputExpression.isReturnTypeFixed()) {
            if (!widgetName.contains(widget.getName()) && compatibleReturnType(inputExpression, e)) {
                input.add(widget);
                widgetName.add(widget.getName());
            }
        } else {
            if (!widgetName.contains(widget.getName())) {
                input.add(widget);
                widgetName.add(widget.getName());
            }
        }
    }
    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(Widget.class, String.class) {

        public Object convert(Object widget) {
            return ((Widget) widget).getName();
        }

    };
    selectionToName.setConverter(nameConverter);

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

        public Object convert(Object widget) {
            return "field_" + ((Widget) widget).getName();
        }

    };
    selectionToContent.setConverter(contentConverter);

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

        public Object convert(Object widget) {
            if (widget instanceof Duplicable && ((Duplicable) widget).isDuplicate()) {
                return List.class.getName();
            } else if (widget instanceof TextFormField && ((Widget) widget).getReturnTypeModifier() != null) {
                return ((Widget) widget).getReturnTypeModifier();
            }
            if (widget instanceof FileWidget) {
                return DocumentValue.class.getName();
            }
            return ((Widget) widget).getAssociatedReturnType();
        }

    };
    selectionToReturnType.setConverter(returnTypeConverter);

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

        public Object convert(Object widget) {
            return Collections.singletonList(widget);
        }

    };
    selectionToReferencedData.setConverter(referenceConverter);

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

        public Object convert(Object widgetList) {
            Widget w = ((List<Widget>) widgetList).get(0);
            Collection<Widget> inputData = (Collection<Widget>) viewer.getInput();
            for (Widget widget : inputData) {
                if (widget.getName().equals(w.getName())
                        && widget.getAssociatedReturnType().equals(w.getAssociatedReturnType())) {
                    return widget;
                }
            }
            return null;
        }

    };
    referencedDataToSelection.setConverter(referencetoDataConverter);
    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.expression.editor.message.MessageIdExpressionEditor.java

License:Open Source License

@Override
public void bindExpression(EMFDataBindingContext dataBindingContext, EObject context,
        Expression inputExpression, ViewerFilter[] filters, ExpressionViewer expressionViewer) {
    this.inputExpression = inputExpression;
    IObservableValue nameModelObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__NAME);
    IObservableValue contentModelObservable = EMFObservables.observeValue(inputExpression,
            ExpressionPackage.Literals.EXPRESSION__CONTENT);

    Set<String> input = new HashSet<String>();
    IExpressionProvider provider = ExpressionEditorService.getInstance()
            .getExpressionProvider(ExpressionConstants.MESSAGE_ID_TYPE);
    for (Expression e : provider.getExpressions(context)) {
        input.add(e.getName());//from  www.j a  v a  2 s . co m
    }
    viewer.setInput(input);

    dataBindingContext.bindValue(SWTObservables.observeText(valueText, SWT.Modify), nameModelObservable);
    dataBindingContext.bindValue(SWTObservables.observeText(valueText, SWT.Modify), contentModelObservable);
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), nameModelObservable);
    dataBindingContext.bindValue(ViewersObservables.observeSingleSelection(viewer), contentModelObservable);
}

From source file:org.bonitasoft.studio.expression.editor.viewer.ExpressionViewer.java

License:Open Source License

protected void bindExpression() {
    if (expressionBinding != null && externalDataBindingContext != null) {
        externalDataBindingContext.removeBinding(expressionBinding);
        expressionBinding.dispose();/*from   w ww. ja v a2s . com*/
    }
    if (internalDataBindingContext != null) {
        internalDataBindingContext.dispose();
    }
    internalDataBindingContext = new EMFDataBindingContext();

    IObservableValue nameObservable = null;
    if (editingDomain != null) {
        nameObservable = EMFEditProperties.value(editingDomain, ExpressionPackage.Literals.EXPRESSION__NAME)
                .observeDetail(ViewerProperties.singleSelection().observe(this));
    } else {
        nameObservable = EMFProperties.value(ExpressionPackage.Literals.EXPRESSION__NAME)
                .observeDetail(ViewerProperties.singleSelection().observe(this));
    }

    IObservableValue typeObservable = null;
    if (editingDomain != null) {
        typeObservable = EMFEditProperties.value(editingDomain, ExpressionPackage.Literals.EXPRESSION__TYPE)
                .observeDetail(ViewerProperties.singleSelection().observe(this));
    } else {
        typeObservable = EMFProperties.value(ExpressionPackage.Literals.EXPRESSION__TYPE)
                .observeDetail(ViewerProperties.singleSelection().observe(this));
    }

    UpdateValueStrategy targetToModelNameStrategy = new UpdateValueStrategy();
    if (mandatoryFieldName != null) {
        targetToModelNameStrategy.setBeforeSetValidator(new EmptyInputValidator(mandatoryFieldName));
    }
    targetToModelNameStrategy.setAfterConvertValidator(new IValidator() {

        @Override
        public IStatus validate(Object value) {
            IExpressionValidator validator = null;
            if (selectedExpression != null) {
                validator = validatorsForType.get(selectedExpression.getType());
            }
            if (validator == null) {
                validator = validatorsForType.get(ExpressionConstants.ALL_TYPES);
            }
            if (validator != null) {
                validator.setDomain(editingDomain);
                validator.setContext(context);
                if (selectedExpression != null) {
                    validator.setInputExpression(selectedExpression);
                }
                setMessage(null, IStatus.OK);
                final IStatus status = validator.validate(value);
                if (status.isOK()) {
                    setMessage(null, status.getSeverity());
                } else {
                    String message = status.getMessage();
                    if (status instanceof MultiStatus) {
                        StringBuilder sb = new StringBuilder();
                        for (IStatus statusChild : status.getChildren()) {
                            sb.append(statusChild.getMessage());
                            sb.append("\n");
                        }
                        if (sb.length() > 0) {
                            sb.delete(sb.length() - 1, sb.length());
                        }
                        message = sb.toString();
                    }
                    setMessage(message, status.getSeverity());
                }
                return status;
            } else {
                setMessage(null, IStatus.OK);
            }
            return ValidationStatus.ok();
        }
    });
    targetToModelNameStrategy.setConverter(getNameConverter());

    final ISWTObservableValue observeDelayedValue = SWTObservables.observeDelayedValue(500,
            SWTObservables.observeText(textControl, SWT.Modify));
    expressionBinding = internalDataBindingContext.bindValue(observeDelayedValue, nameObservable,
            targetToModelNameStrategy, null);

    expressionBinding.getValidationStatus().addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(ValueChangeEvent event) {
            IStatus status = (IStatus) event.diff.getNewValue();
            fireValidationStatusChanged(status.getSeverity());
        }
    });

    bindEditableText(typeObservable);
    nameObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(ValueChangeEvent arg0) {
            fireSelectionChanged(new SelectionChangedEvent(ExpressionViewer.this, getSelection()));
        }
    });
    if (externalDataBindingContext != null) {
        externalDataBindingContext.addBinding(expressionBinding);
    }
}