org.eclipse.core.databinding.observable.value.IValueChangeListener Java Examples

private void createGeneralLastNameField(final Composite detailsInfoComposite) {
    final Label lastName = new Label(detailsInfoComposite, SWT.NONE);
    lastName.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    lastName.setText(Messages.lastName);

    final Text lastNameText = new Text(detailsInfoComposite, SWT.BORDER);
    lastNameText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
    lastNameText.setMessage(Messages.lastNameHint);

    final IObservableValue lastNameUserValue = EMFObservables.observeDetailValue(Realm.getDefault(),
            userSingleSelectionObservable,
            OrganizationPackage.Literals.USER__LAST_NAME);
    context.bindValue(SWTObservables.observeText(lastNameText, SWT.Modify), lastNameUserValue);

    lastNameUserValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            handleLastNameChange(event);
        }
    });
}
 

private void updateVisibilityOfActionExpressionControl(final IObservableValue operationObservableValue) {
    operationObservableValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(ValueChangeEvent event) {
            final IObservableValue observableValue = event.getObservableValue();
            final Operation operation = (Operation) observableValue.getValue();
            final boolean isLeftOperandABusinessData = operation != null
                    && isExpressionReferenceABusinessData(operation.getLeftOperand());
            final Control control = getActionExpression().getControl();
            if (!control.isDisposed()) {
                control.setVisible(
                        !ExpressionConstants.DELETION_OPERATOR.equals(operation.getOperator().getType())
                                || !isLeftOperandABusinessData);
            }
        }
    });

}
 

private void bindOperator(EMFDataBindingContext context, IObservableValue operationObervable) {
    final UpdateValueStrategy uvsOperator = new UpdateValueStrategy();
    final IObservableValue operatorObservableValue = CustomEMFEditObservables.observeDetailValue(Realm.getDefault(),
            operationObervable,
            ExpressionPackage.Literals.OPERATION__OPERATOR);
    final IObservableValue operatorExpressionObserveValue = CustomEMFEditObservables.observeDetailValue(
            Realm.getDefault(), operatorObservableValue,
            ExpressionPackage.Literals.OPERATOR__EXPRESSION);
    final IObservableValue operatorTypeObservedValue = CustomEMFEditObservables.observeDetailValue(Realm.getDefault(),
            operatorObservableValue,
            ExpressionPackage.Literals.OPERATOR__TYPE);
    uvsOperator.setConverter(new OperatorTypeToStringLinkConverter(operatorObservableValue));
    operatorTypeObservedValue.addChangeListener(new RevalidateActionExpressionChangeListener());
    operatorTypeObservedValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            getActionExpression().setDefaultReturnType(defaultReturnTypeResolver.guessRightOperandReturnType());
        }
    });

    context.bindValue(SWTObservables.observeText(getOperatorLink()), operatorTypeObservedValue, null, uvsOperator);
    context.bindValue(SWTObservables.observeText(getOperatorLink()), operatorExpressionObserveValue, null, uvsOperator);
    context.bindValue(SWTObservables.observeTooltipText(getOperatorLink()),
            operatorExpressionObserveValue);
}
 

private void createDisplayNameField(final Group group) {
    final Label displayNameLabel = new Label(group, SWT.NONE);
    displayNameLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    displayNameLabel.setText(Messages.displayName);

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

    final IObservableValue roleDisplayNameValue = EMFObservables.observeDetailValue(Realm.getDefault(),
            roleSingleSelectionObservable, OrganizationPackage.Literals.ROLE__DISPLAY_NAME);
    final Binding binding = context.bindValue(SWTObservables.observeText(displayNamedText, SWT.Modify),
            roleDisplayNameValue,
            updateValueStrategy().withValidator(maxLengthValidator(Messages.displayName, LONG_FIELD_MAX_LENGTH))
                    .create(),
            null);
    ControlDecorationSupport.create(binding, SWT.LEFT);

    roleDisplayNameValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent arg0) {
            handleRoleDisplayNameChange(arg0);

        }
    });
}
 

private void createDescriptionField(final Group group) {
    final Label descriptionLabel = new Label(group, SWT.NONE);
    descriptionLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.FILL).create());
    descriptionLabel.setText(Messages.description);

    final Text roleDescriptionText = new Text(group, SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
    roleDescriptionText
            .setLayoutData(GridDataFactory.fillDefaults().grab(true, false).hint(SWT.DEFAULT, 80).create());
    roleDescriptionText.setMessage(Messages.descriptionHint);
    roleDescriptionText.setTextLimit(255);

    final IObservableValue roleDescriptionValue = EMFObservables.observeDetailValue(Realm.getDefault(),
            roleSingleSelectionObservable, OrganizationPackage.Literals.ROLE__DESCRIPTION);
    context.bindValue(SWTObservables.observeText(roleDescriptionText, SWT.Modify), roleDescriptionValue);
    roleDescriptionValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            handleRoleDescriptionChange(event);
        }
    });
}
 

private void createGeneralFirstNameField(final Composite detailsInfoComposite) {
    final Label firstName = new Label(detailsInfoComposite, SWT.NONE);
    firstName.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    firstName.setText(Messages.firstName);

    final Text firstNameText = new Text(detailsInfoComposite, SWT.BORDER);
    firstNameText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
    firstNameText.setMessage(Messages.firstNameHint);

    final IObservableValue firstNameUserValue = EMFObservables.observeDetailValue(Realm.getDefault(),
            userSingleSelectionObservable,
            OrganizationPackage.Literals.USER__FIRST_NAME);
    context.bindValue(SWTObservables.observeText(firstNameText, SWT.Modify), firstNameUserValue);

    firstNameUserValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            handleFirstNameChange(event);
        }
    });
}
 

@Override
protected void createBinding(final EMFDataBindingContext context) {
    observable = SWTObservables.observeDelayedValue(250, SWTObservables.observeText(text, SWT.Modify));

    final IObservableValue nameObservable = EMFEditObservables.observeValue(editingDomain, element,
            ProcessPackage.Literals.ELEMENT__NAME);
    nameObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            updatePropertyTabTitle();
            updatePartName((String) event.diff.getNewValue(), Display.getDefault());
        }
    });
    context.bindValue(observable,
            nameObservable);
    final MultiValidator validationStatusProvider = nameValidationStatusProvider(observable);
    context.addValidationStatusProvider(validationStatusProvider);
    ControlDecorationSupport.create(validationStatusProvider, SWT.LEFT);
    bindingInitialized = true;
}
 

@Override
protected void setInput ( final IEditorInput input )
{
    final ConfigurationEditorInput configurationInput = (ConfigurationEditorInput)input;

    if ( !this.nested )
    {
        configurationInput.performLoad ( new NullProgressMonitor () );
    }

    this.dirtyValue = configurationInput.getDirtyValue ();
    this.dirtyValue.addValueChangeListener ( new IValueChangeListener () {

        @Override
        public void handleValueChange ( final ValueChangeEvent event )
        {
            firePropertyChange ( IEditorPart.PROP_DIRTY );
        }
    } );

    super.setInput ( input );
}
 

@Override
protected void bind ()
{
    this.dbc.bindValue ( SWTObservables.observeText ( this.label ), this.model, null, new UpdateValueStrategy ().setConverter ( new VariantToStringConverter () ) );
    this.model.addValueChangeListener ( new IValueChangeListener () {

        @Override
        public void handleValueChange ( final ValueChangeEvent event )
        {
            if ( !PlainDataItemLabel.this.label.isDisposed () )
            {
                PlainDataItemLabel.this.label.getParent ().layout ();
            }
        }
    } );
}
 

public void setTitle() {
    if (selectedDataObservable.getValue() != null) {
        setTitle(Messages.bind(Messages.selectFieldToGenerateTitle,
                ((Element) selectedDataObservable.getValue()).getName()));
        EMFObservables
                .observeDetailValue(Realm.getDefault(), selectedDataObservable,
                        ProcessPackage.Literals.ELEMENT__NAME)
                .addValueChangeListener(
                        new IValueChangeListener() {

                            @Override
                            public void handleValueChange(final ValueChangeEvent event) {
                                setTitle(Messages.bind(Messages.selectFieldToGenerateTitle,
                                        event.diff.getNewValue()));
                            }
                        });
    }
}
 

@Override
protected IObservableValue doCreateElementObservable(final Object element, final ViewerCell viewerCell) {
    final IObservableValue observeValue = PojoObservables.observeValue(element, "name");
    observeValue.addValueChangeListener(new ColumnViewerUpdateListener(getViewer(), element));
    observeValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            final String oldInformationName = (String) event.diff.getOldValue();
            final String newInformationName = (String) event.diff.getNewValue();
            for(final User user : organization.getUsers().getUser()){
                updateCustomUserInformationName(user, oldInformationName, newInformationName);
            }
        }

    });

    //sort the table after a modification
    observeValue.addDisposeListener(new IDisposeListener() {

        @Override
        public void handleDispose(final DisposeEvent arg0) {
            viewer.refresh();

        }
    });
    return observeValue;
}
 

@Override
protected void createContent(final Composite parent) {
    context = new EMFDataBindingContext();
    final TabbedPropertySheetWidgetFactory widgetFactory = getWidgetFactory();

    final Composite composite = widgetFactory.createPlainComposite(parent, SWT.NONE);
    composite.setLayout(GridLayoutFactory.fillDefaults().numColumns(1).margins(10, 5).create());
    composite.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

    final SelectObservableValue recurrenceTypeObservable = createRecurrenceTypeRadioGroup(composite, widgetFactory);

    final Composite stackedComposite = widgetFactory.createPlainComposite(composite, SWT.NONE);
    stackedComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
    final StackLayout stackLayout = new StackLayout();
    stackedComposite.setLayout(stackLayout);

    final Composite noneComposite = widgetFactory.createComposite(stackedComposite, SWT.NONE);
    final Composite standardLoopContent = createStandardLoopContent(stackedComposite, widgetFactory);
    final Composite multiInstanceContent = createMultiInstanceContent(stackedComposite, widgetFactory);
    recurrenceTypeObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            final MultiInstanceType type = (MultiInstanceType) event.diff.getNewValue();
            switch (type) {
                case NONE:
                    stackLayout.topControl = noneComposite;
                    break;
                case STANDARD:
                    stackLayout.topControl = standardLoopContent;
                    break;
                default:
                    stackLayout.topControl = multiInstanceContent;
                    break;
            }
            stackedComposite.layout();
        }
    });

}
 

private void createDisplayNameField(final Group group) {
    final Label displayNameLabel = new Label(group, SWT.NONE);
    displayNameLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    displayNameLabel.setText(Messages.displayName);

    final Text displayNamedText = new Text(group, SWT.BORDER);
    displayNamedText.setMessage(Messages.groupNameExample);
    displayNamedText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

    final IObservableValue displayNameValue = EMFObservables.observeDetailValue(Realm.getDefault(), groupSingleSelectionObservable,
            OrganizationPackage.Literals.GROUP__DISPLAY_NAME);
    final Binding binding = context.bindValue(SWTObservables.observeText(displayNamedText, SWT.Modify), displayNameValue,
            UpdateStrategyFactory.updateValueStrategy()
                    .withValidator(maxLengthValidator(Messages.displayName, LONG_FIELD_MAX_LENGTH)).create(),
            null);
    ControlDecorationSupport.create(binding, SWT.LEFT);

    displayNameValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            handleGroupDisplayName(event);
        }

    });

}
 

@Override
protected void bind ()
{
    this.model.addValueChangeListener ( new IValueChangeListener () {

        @Override
        public void handleValueChange ( final ValueChangeEvent event )
        {
            if ( !SystemMessageLabel.this.label.isDisposed () )
            {
                process ( event.diff.getNewValue () );
            }
        }
    } );
}
 

@Override
protected void configureViewer(final StructuredViewer viewer) {

    final TableViewer roleTableViewer = (TableViewer) viewer;
    final Table table = roleTableViewer.getTable();

    roleSingleSelectionObservable = ViewersObservables.observeSingleSelection(getViewer());
    roleSingleSelectionObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            final Role selectedRole = (Role) event.diff.getNewValue();
            final boolean isSelectedRole = selectedRole != null;
            setControlEnabled(getInfoGroup(), isSelectedRole);
            roleMemberShips.clear();
            for (final Membership m : membershipList) {
                if (Objects.equals(selectedRole.getName(),m.getRoleName())) {
                    roleMemberShips.add(m);
                }
            }
        }
    });

    addNameColumn(roleTableViewer);

    addDisplayNameColumn(roleTableViewer);

    addDescriptionColumn(roleTableViewer);

    addTableColumLayout(table);

    if (roleList != null && getViewer() != null) {
        getViewer().setInput(roleList);
    }

}
 

@Override
protected Binding createBinding(final IObservableValue target, final IObservableValue model) {
    final Binding binding = dbc.bindValue(target, model, targetToModelConvertStrategy(observedElement(model)), null);
    final IObservableValue validationStatus = binding.getValidationStatus();
    validationStatus.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            validationStatusChanged((IStatus) event.diff.getNewValue());
        }

    });
    return binding;
}
 

public TimeShiftActionController ( final ControllerManager controllerManager, final ChartContext chartContext, final TimeShiftAction controller )
{
    super ( controllerManager.getContext (), chartContext, controller );

    final DataBindingContext ctx = controllerManager.getContext ();

    final Composite space = chartContext.getExtensionSpaceProvider ().getExtensionSpace ();
    if ( space != null )
    {
        this.button = new Button ( space, SWT.PUSH );
        this.button.addSelectionListener ( new SelectionAdapter () {
            @Override
            public void widgetSelected ( final SelectionEvent e )
            {
                action ();
            };
        } );
        addBinding ( ctx.bindValue ( PojoObservables.observeValue ( this, "milliseconds" ), EMFObservables.observeValue ( controller, ChartPackage.Literals.TIME_SHIFT_ACTION__DIFF ) ) ); //$NON-NLS-1$
        addBinding ( ctx.bindValue ( SWTObservables.observeText ( this.button ), EMFObservables.observeValue ( controller, ChartPackage.Literals.TIME_SHIFT_ACTION__LABEL ) ) );
        addBinding ( ctx.bindValue ( SWTObservables.observeTooltipText ( this.button ), EMFObservables.observeValue ( controller, ChartPackage.Literals.TIME_SHIFT_ACTION__DESCRIPTION ) ) );

        this.layoutListener = new IValueChangeListener () {

            @Override
            public void handleValueChange ( final ValueChangeEvent event )
            {
                space.layout ();
            }
        };

        this.labelProperty = EMFObservables.observeValue ( controller, ChartPackage.Literals.TIME_SHIFT_ACTION__LABEL );
        this.labelProperty.addValueChangeListener ( this.layoutListener );

        space.layout ();
    }
    else
    {
        this.button = null;
    }
}
 

private void createNameField(final Group group) {
    final Label roleName = new Label(group, SWT.NONE);
    roleName.setLayoutData(GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).create());
    roleName.setText(Messages.name + " *");

    final Text roleNameText = new Text(group, SWT.BORDER);
    roleNameText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).minSize(130, SWT.DEFAULT).create());

    final IObservableValue roleNameValue = EMFObservables.observeDetailValue(Realm.getDefault(),
            roleSingleSelectionObservable, OrganizationPackage.Literals.ROLE__NAME);
    final Binding binding = context.bindValue(SWTObservables.observeText(roleNameText, SWT.Modify),
            roleNameValue,
            updateValueStrategy().withValidator(multiValidator()
                    .addValidator(mandatoryValidator(Messages.name))
                    .addValidator(maxLengthValidator(Messages.name, LONG_FIELD_MAX_LENGTH))
                    .addValidator(new UniqueRoleNameValidator()).create()).create(),
            null);

    ControlDecorationSupport.create(binding, SWT.LEFT, group, new ControlDecorationUpdater() {

        @Override
        protected void update(final ControlDecoration decoration, final IStatus status) {
            if (roleSingleSelectionObservable.getValue() != null) {
                super.update(decoration, status);
            }
        }
    });
    roleNameValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            handleRoleNameChange(event);
        }
    });
}
 

public void bindControl(final DataBindingContext dbc, final IObservableValue modelObservable) {
    final DateTimeObservable dateObservable = new DateTimeObservable(dateControl);
    final DateTimeObservable timeObservable = new DateTimeObservable(timeControl);
    dbc.bindValue(dateObservable, modelObservable);
    dateControl.notifyListeners(SWT.Selection, new Event());
    timeObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            final Date newValue = (Date) event.diff.getNewValue();
            dateControl.setTime(newValue.getHours(), newValue.getMinutes(), newValue.getMinutes());
            dateControl.notifyListeners(SWT.Selection, new Event());
        }
    });
}
 

private void createSingleMultipleRadioGroup(final Composite parent, final EMFDataBindingContext emfDataBindingContext) {
    //FILLER
    final Label filler = new Label(parent, SWT.NONE);
    filler.setLayoutData(GridDataFactory.swtDefaults().grab(false, false).create());

    final Composite radioContainer = new Composite(parent, SWT.NONE);
    radioContainer.setLayout(GridLayoutFactory.fillDefaults().numColumns(2).margins(0, 0).create());
    radioContainer.setLayoutData(GridDataFactory.swtDefaults().grab(true, false).create());
    final Button radioButtonSingle = createRadioButtonSingle(radioContainer);
    final Button radioButtonMultiple = createRadioButtonMultiple(radioContainer);

    final SelectObservableValue isMultipleObservableValue = new SelectObservableValue(Boolean.class);
    isMultipleObservableValue.addOption(false, SWTObservables.observeSelection(radioButtonSingle));
    isMultipleObservableValue.addOption(true, SWTObservables.observeSelection(radioButtonMultiple));

    final IObservableValue multipleObserveValue = EMFObservables.observeValue(document, ProcessPackage.Literals.DOCUMENT__MULTIPLE);
    emfDataBindingContext.bindValue(
            isMultipleObservableValue,
            multipleObserveValue);
    multipleObserveValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            validate(emfDataBindingContext);
        }
    });

}
 

private void createDocumentTypeRadioButtonComposition(final Composite parent, final EMFDataBindingContext emfDataBindingContext) {
    final Composite compo = new Composite(parent, SWT.NONE);
    compo.setLayout(GridLayoutFactory.fillDefaults().numColumns(4).spacing(10, 5).create());
    compo.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

    final Button radioButtonNone = createRadioButtonNone(compo);
    final Button radioButtonContract = createRadioButtonContract(compo);
    final Button radioButtonInternal = createRadioButtonInternal(compo);
    final Button radioButtonExternal = createRadioButtonExternal(compo);

    final SelectObservableValue documentTypeObservableValue = new SelectObservableValue(DocumentType.class);
    documentTypeObservableValue.addOption(DocumentType.NONE, SWTObservables.observeSelection(radioButtonNone));
    documentTypeObservableValue.addOption(DocumentType.CONTRACT, SWTObservables.observeSelection(radioButtonContract));
    documentTypeObservableValue.addOption(DocumentType.EXTERNAL, SWTObservables.observeSelection(radioButtonExternal));
    documentTypeObservableValue.addOption(DocumentType.INTERNAL, SWTObservables.observeSelection(radioButtonInternal));

    final IObservableValue documentTypeObservable = EMFObservables.observeValue(document, ProcessPackage.Literals.DOCUMENT__DOCUMENT_TYPE);
    emfDataBindingContext.bindValue(
            documentTypeObservableValue,
            documentTypeObservable);
    documentTypeObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            validate(emfDataBindingContext);
        }
    });
}
 

/**
 * Setup additional non-component contained bindings
 */
protected void setupBindings() {

	DataBindingContext dataBindingContext = this.getDataBindingContext();

	IObservableValue<String> moduleSpecifierValue = BeanProperties
			.value(WorkspaceWizardModel.class, WorkspaceWizardModel.MODULE_SPECIFIER_PROPERTY, String.class)
			.observe(getModel());

	IObservableValue<Boolean> suffixVisibilityValue = BeanProperties
			.value(SuffixText.class, SuffixText.SUFFIX_VISIBILITY_PROPERTY, Boolean.class)
			.observe(workspaceWizardControl.getModuleSpecifierText());

	//// Only show the suffix on input values ending with a '/' character or empty module specifiers.
	dataBindingContext.bindValue(suffixVisibilityValue, moduleSpecifierValue, noUpdateValueStrategy(),
			WizardComponentDataConverters.strategyForPredicate(m -> {
				String moduleSpecifier = (String) m;
				return (moduleSpecifier.isEmpty()
						|| moduleSpecifier.charAt(moduleSpecifier.length() - 1) == IPath.SEPARATOR);
			}));

	//// interface name to module specifier suffix binding
	IObservableValue<String> interfaceNameModelValue = BeanProperties
			.value(N4JSClassifierWizardModel.class, N4JSClassifierWizardModel.NAME_PROPERTY, String.class)
			.observe(getModel());
	IObservableValue<String> greySuffixValue = BeanProperties
			.value(SuffixText.class, SuffixText.SUFFIX_PROPERTY, String.class)
			.observe(workspaceWizardControl.getModuleSpecifierText());
	dataBindingContext.bindValue(greySuffixValue,
			interfaceNameModelValue, noUpdateValueStrategy(),
			new UpdateValueStrategy<>(UpdateValueStrategy.POLICY_UPDATE));

	//// Enable n4js <-> Definition value(external) is selected
	IObservableValue<Boolean> externalValue = BeanProperties
			.value(DefinitionFileModel.class, N4JSClassifierWizardModel.DEFINITION_FILE_PROPERTY, Boolean.class)
			.observe((DefinitionFileModel) getModel());
	IObservableValue<Boolean> n4jsEnabled = WidgetProperties.enabled()
			.observe(otherClassifierModifiersComponent.getN4jsAnnotationBox());
	dataBindingContext.bindValue(n4jsEnabled, externalValue, noUpdateValueStrategy(),
			WizardComponentDataConverters.strategyForPredicate(input -> getModel().isDefinitionFile()
					&& AccessModifier.PRIVATE != getModel().getAccessModifier()));

	// One way binding of the access modifiers to the enabled state of internal checkbox
	IObservableValue<Boolean> internalEnabledValue = WidgetProperties.enabled()
			.observe(accessModifierComponent.getInternalAnnotationBox());
	IObservableValue<AccessModifier> accessModifierSelectObservable = BeanProperties
			.value(N4JSClassifierWizardModel.class, N4JSClassifierWizardModel.ACCESS_MODIFIER_PROPERTY,
					AccessModifier.class)
			.observe(getModel());

	dataBindingContext.bindValue(internalEnabledValue, accessModifierSelectObservable, noUpdateValueStrategy(),
			WizardComponentDataConverters.strategyForPredicate(object -> {
				if (object instanceof AccessModifier) {
					return isInternalAccessModifierEnabled((AccessModifier) object);
				}
				return false;
			}));

	// N4JS annotation checkbox disabled when access modifier is private
	IObservableValue<Boolean> n4jsEnabledValue = WidgetProperties.enabled()
			.observe(otherClassifierModifiersComponent.getN4jsAnnotationBox());
	dataBindingContext.bindValue(n4jsEnabledValue, accessModifierSelectObservable, noUpdateValueStrategy(),
			WizardComponentDataConverters.strategyForPredicate(object -> {
				if (object instanceof AccessModifier) {
					return ((AccessModifier) object != AccessModifier.PRIVATE) && getModel().isDefinitionFile();
				}
				return false;
			}));

	// Refresh wizard state on validation change
	IObservableValue<ValidationResult> observableValidationValue = BeanProperties
			.value(WorkspaceWizardModelValidator.VALIDATION_RESULT, ValidationResult.class)
			.observe(getValidator());
	observableValidationValue.addValueChangeListener(new IValueChangeListener<ValidationResult>() {
		@Override
		public void handleValueChange(ValueChangeEvent<? extends ValidationResult> event) {
			onValidationChange(event.diff.getNewValue());
		}
	});

}
 

private void createQueryParametersTable(final Composite parent) {
    final Composite composite = new Composite(parent, SWT.NONE);
    composite.setLayoutData(GridDataFactory.fillDefaults().span(2, 1).grab(true, true).create());
    composite.setLayout(GridLayoutFactory.fillDefaults().numColumns(1).margins(0, 0).spacing(0, 2).create());

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

    final ControlDecoration parameterDecoration = new ControlDecoration(parameterLabel, SWT.RIGHT);
    parameterDecoration.setShowOnlyOnFocus(false);
    parameterDecoration.setDescriptionText(Messages.paginationParameterHint);
    parameterDecoration.setImage(Pics.getImage(PicsConstants.hint));
    parameterDecoration.hide();
    observeQuerySingleSelection.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            final Object newValue = event.diff.getNewValue();
            if (newValue instanceof Expression) {
                if (List.class.getName().equals(((Expression) newValue).getReturnType())) {
                    parameterDecoration.show();
                } else {
                    parameterDecoration.hide();
                }
            }

        }
    });

    final TableViewer parametersTableViewer = new TableViewer(composite,
            SWT.FULL_SELECTION | SWT.BORDER | SWT.V_SCROLL);
    parametersTableViewer.getControl()
            .setLayoutData(GridDataFactory.fillDefaults().grab(true, true).hint(SWT.DEFAULT, 80).create());
    parametersTableViewer.getTable().setLinesVisible(true);
    parametersTableViewer.getTable().setHeaderVisible(true);
    parametersTableViewer.setContentProvider(new ObservableListContentProvider());

    queryParameterObserveDetailList = EMFObservables.observeDetailList(Realm.getDefault(),
            observeQuerySingleSelection,
            ExpressionPackage.Literals.EXPRESSION__REFERENCED_ELEMENTS);

    final TableLayout tableLayout = new TableLayout();
    tableLayout.addColumnData(new ColumnWeightData(1, true));
    tableLayout.addColumnData(new ColumnWeightData(1, true));
    parametersTableViewer.getTable().setLayout(tableLayout);

    createNameColumn(parametersTableViewer);
    createValueColumn(parametersTableViewer);

    parametersTableViewer.setInput(queryParameterObserveDetailList);
}
 

private void createQueryComboViewer(final Composite composite, final IObservableList observeQueryList) {
    final Composite queryComposite = new Composite(composite, SWT.NONE);
    queryComposite.setLayoutData(GridDataFactory.fillDefaults().create());
    queryComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(1).margins(0, 0).spacing(0, 2).create());

    final Label queryLabel = new Label(queryComposite, SWT.NONE);
    queryLabel.setLayoutData(GridDataFactory.fillDefaults().align(SWT.LEFT, SWT.CENTER).create());
    queryLabel.setText(Messages.queries);

    final ComboViewer queryCombo = new ComboViewer(queryComposite, SWT.READ_ONLY | SWT.BORDER);
    queryCombo.getControl().setLayoutData(
            GridDataFactory.fillDefaults().grab(true, false).hint(150, SWT.DEFAULT).create());
    queryCombo.setLabelProvider(new LabelProvider() {

        @Override
        public String getText(final Object element) {
            if (element instanceof Expression) {
                String name = ((Expression) element).getName();
                if (name.indexOf(".") != -1) {
                    name = name.substring(name.indexOf(".") + 1, name.length());
                }
                return name;
            }
            return super.getText(element);
        }
    });
    queryCombo.setContentProvider(new ObservableListContentProvider());

    queryCombo.setInput(observeQueryList);

    observeQuerySingleSelection = ViewersObservables.observeSingleSelection(queryCombo);
    observeBOSingleSelection.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            if (event.diff.getOldValue() != null && observeQuerySingleSelection.getValue() == null) {
                observeQuerySingleSelection.setValue(observeQueryList.get(0));
            }
        }
    });
}
 

@SuppressWarnings("unchecked")
public void initDataBindings(){
	DataBindingContext bindingContext = new DataBindingContext();
	
	//
	ISWTObservableValue observeTextTxtProductNameObserveWidget =
		WidgetProperties.text(SWT.Modify).observeDelayed(300, txtProductName);
	IObservableValue<String> productEigenartikelNameObserveDetailValue = PojoProperties
		.value(IArticle.class, "name", String.class).observeDetail(productEigenartikel);
	bindingContext.bindValue(observeTextTxtProductNameObserveWidget,
		productEigenartikelNameObserveDetailValue,
		new SavingUpdateProductChilds(CoreModelServiceHolder.get(), productEigenartikel), null);
	observeTextTxtProductNameObserveWidget.addValueChangeListener(new IValueChangeListener() {
		@Override
		public void handleValueChange(ValueChangeEvent event){
			if (productEigenartikel.getValue() != null) {
				if (event.diff.getOldValue() != null
					&& !event.diff.getOldValue().toString().isEmpty()) {
					ContextServiceHolder.get().postEvent(ElexisEventTopics.EVENT_UPDATE,
						productEigenartikel.getValue());
				}
			}
		}
	});
	
	//
	IViewerObservableValue observeSingleSelectionComboViewerProductType =
		ViewerProperties.singleSelection().observe(comboViewerProductType);
	IObservableValue<IArticle> productEigenartikelTypObserveDetailValue =
		PojoProperties.value(IArticle.class, "subTyp", ArticleSubTyp.class)
			.observeDetail(productEigenartikel);
	bindingContext.bindValue(observeSingleSelectionComboViewerProductType,
		productEigenartikelTypObserveDetailValue,
		new SavingUpdateProductChilds(CoreModelServiceHolder.get(), productEigenartikel), null);
	
	//
	ISWTObservableValue observeTextTxtAtcCodeObserveWidget =
		WidgetProperties.text(SWT.Modify).observeDelayed(300, txtAtcCode);
	IObservableValue<String> productEigenartikelATC_codeObserveDetailValue = PojoProperties
		.value(IArticle.class, "atcCode", String.class).observeDetail(productEigenartikel);
	bindingContext.bindValue(observeTextTxtAtcCodeObserveWidget,
		productEigenartikelATC_codeObserveDetailValue,
		new SavingUpdateProductChilds(CoreModelServiceHolder.get(), productEigenartikel), null);
}
 

private Composite createMultiInstanceContent(final Composite stackedComposite,
        final TabbedPropertySheetWidgetFactory widgetFactory) {
    final Composite multiInstanceComposite = widgetFactory.createPlainComposite(stackedComposite, SWT.NONE);
    multiInstanceComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
    multiInstanceComposite
            .setLayout(GridLayoutFactory.fillDefaults().numColumns(3).extendedMargins(30, 0, 15, 0).create());

    final Composite cardinalityRadioGroup = widgetFactory.createPlainComposite(multiInstanceComposite, SWT.NONE);
    cardinalityRadioGroup.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(3, 1).create());
    cardinalityRadioGroup.setLayout(GridLayoutFactory.fillDefaults().numColumns(2).create());

    final Button dataBasedInstanceButton = widgetFactory.createButton(cardinalityRadioGroup,
            Messages.dataBasedInstanceLabel, SWT.RADIO);
    dataBasedInstanceButton.setLayoutData(GridDataFactory.swtDefaults().create());

    final Button definedNumberOfInstancesButton = widgetFactory.createButton(cardinalityRadioGroup,
            Messages.definedNumberOfInstanceLabel, SWT.RADIO);
    definedNumberOfInstancesButton.setLayoutData(GridDataFactory.swtDefaults().create());

    final SelectObservableValue cardinalityObservable = new SelectObservableValue(Boolean.class);
    cardinalityObservable.addOption(Boolean.FALSE, SWTObservables.observeSelection(dataBasedInstanceButton));
    cardinalityObservable.addOption(Boolean.TRUE, SWTObservables.observeSelection(definedNumberOfInstancesButton));

    context.bindValue(cardinalityObservable,
            CustomEMFEditObservables.observeDetailValue(Realm.getDefault(),
                    ViewersObservables.observeSingleSelection(selectionProvider),
                    ProcessPackage.Literals.MULTI_INSTANTIABLE__USE_CARDINALITY));

    final Composite dataContainerComposite = widgetFactory.createPlainComposite(multiInstanceComposite, SWT.NONE);
    dataContainerComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(3, 1).create());
    final StackLayout dataStackLayout = new StackLayout();
    dataContainerComposite.setLayout(dataStackLayout);

    final Composite cardinalityContent = createCardinalityContent(dataContainerComposite, widgetFactory);
    final Composite dataContent = createDataContent(dataContainerComposite, widgetFactory);

    cardinalityObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            final Boolean useCardinality = (Boolean) event.diff.getNewValue();
            if (useCardinality) {
                dataStackLayout.topControl = cardinalityContent;

            } else {
                dataStackLayout.topControl = dataContent;
            }
            dataContainerComposite.layout();

        }
    });

    return multiInstanceComposite;

}
 

private IValueChangeListener handleValidationStatusChanged() {
    return event -> {
        statusChanged((IStatus) event.diff.getNewValue());
    };
}
 

private void createMultipleComposite(final Composite parent, final EMFDataBindingContext emfDataBindingContext) {
    multipleComposite = new Composite(parent, SWT.NONE);
    multipleComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
    multipleComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(2).margins(10, 10).create());

    final Composite radioContainer = new Composite(multipleComposite, SWT.NONE);
    radioContainer.setLayout(GridLayoutFactory.fillDefaults().numColumns(3).margins(0, 0).spacing(10, 5).create());
    radioContainer.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).span(2, 1).create());

    final Button radioButtonNone = createRadioButtonNone(radioContainer);
    final Button radioButtonContract = createRadioButtonContract(radioContainer);
    final Button radioButtonScript = createRadioButtonInternal(radioContainer);
    radioButtonScript.setText(Messages.initialValueButtonScript);

    final SelectObservableValue documentTypeObservableValue = new SelectObservableValue(DocumentType.class);
    final ISWTObservableValue scriptObserveSelection = SWTObservables.observeSelection(radioButtonScript);
    documentTypeObservableValue.addOption(DocumentType.NONE, SWTObservables.observeSelection(radioButtonNone));
    documentTypeObservableValue.addOption(DocumentType.INTERNAL, scriptObserveSelection);
    documentTypeObservableValue.addOption(DocumentType.CONTRACT, SWTObservables.observeSelection(radioButtonContract));

    final IObservableValue documentTypeObservable = EMFObservables.observeValue(document, ProcessPackage.Literals.DOCUMENT__DOCUMENT_TYPE);
    emfDataBindingContext.bindValue(documentTypeObservableValue, documentTypeObservable, null,
            updateValueStrategy().withConverter(internalOrExternalToTrue())
                    .create());
    documentTypeObservable.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            validate(emfDataBindingContext);
        }
    });

    multipleStackedComposite = new Composite(multipleComposite, SWT.NONE);
    multipleStackedComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
    multipleStack = new StackLayout();
    multipleStackedComposite.setLayout(multipleStack);

    multiNoneCompo = new Composite(multipleStackedComposite, SWT.NONE);
    multiNoneCompo.setLayoutData(GridDataFactory.swtDefaults().grab(false, false).create());

    multipleContractComposite = new MultipleFileContractInputSelectionComposite(multipleStackedComposite);
    multipleContractComposite.bindControl(document, context, emfDataBindingContext);
    scriptComposite = createScriptComposite(multipleStackedComposite, emfDataBindingContext);
}
 

private IValueChangeListener handleValidationStatusChanged() {
    return event -> statusChanged((IStatus) bindValue.getValidationStatus().getValue());
}
 

private void createUserNameField(final Composite rightColumnComposite) {
    final Label userName = new Label(rightColumnComposite, SWT.NONE);
    userName.setLayoutData(GridDataFactory.fillDefaults().align(SWT.BEGINNING, SWT.CENTER).create());
    userName.setText(Messages.userName + " *");

    final Text usernameText = new Text(rightColumnComposite, SWT.BORDER);
    usernameText.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).indent(5, 0).create());
    usernameText.setMessage(Messages.userNameHint);

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

        @Override
        public Object convert(final Object from) {
            if (from != null && userSingleSelectionObservable != null
                    && userSingleSelectionObservable.getValue() != null) {
                final User user = (User) userSingleSelectionObservable.getValue();
                updateDelegueeMembership(user.getUserName(), from.toString());
            }
            return from;
        }
    });
    stategy.setAfterGetValidator(new IValidator() {

        @Override
        public IStatus validate(final Object value) {

            if (isNotUserSelected()) {
                return Status.OK_STATUS;
            }

            if (value.toString().isEmpty()) {
                return ValidationStatus.error(Messages.userNameIsEmpty);
            }

            if (value.toString().length() > NAME_SIZE) {
                return ValidationStatus.error(Messages.nameLimitSize);
            }

            final User currentUser = (User) userSingleSelectionObservable.getValue();
            for (final User u : userList) {
                if (!u.equals(currentUser)) {
                    if (u.getUserName().equals(value)) {
                        return ValidationStatus.error(Messages.userNameAlreadyExists);
                    }
                }
            }
            return Status.OK_STATUS;
        }
    });

    final IObservableValue userNameValue = EMFObservables.observeDetailValue(Realm.getDefault(),
            userSingleSelectionObservable,
            OrganizationPackage.Literals.USER__USER_NAME);
    final Binding binding = context.bindValue(SWTObservables.observeText(usernameText, SWT.Modify), userNameValue,
            stategy, null);
    ControlDecorationSupport.create(binding, SWT.LEFT, rightColumnComposite, new ControlDecorationUpdater() {

        @Override
        protected void update(final ControlDecoration decoration, final IStatus status) {
            if (userSingleSelectionObservable.getValue() != null) {
                super.update(decoration, status);
            }
        }
    });

    userNameValue.addValueChangeListener(new IValueChangeListener() {

        @Override
        public void handleValueChange(final ValueChangeEvent event) {
            handleUserNameChange(event);
        }

    });
}