/** * Constructs an observable value * * @param target * the observable value to be wrapped * @param validationStatus * an observable value of type {@link IStatus}.class which * contains the current validation status */ public ValidatedObservableValue(IObservableValue<T> target, IObservableValue<IStatus> validationStatus) { super(target.getRealm()); Assert.isNotNull(validationStatus, "Validation status observable cannot be null"); //$NON-NLS-1$ Assert.isTrue(target.getRealm().equals(validationStatus.getRealm()), "Target and validation status observables must be on the same realm"); //$NON-NLS-1$ this.target = target; this.validationStatus = validationStatus; this.cachedValue = target.getValue(); target.addValueChangeListener(targetChangeListener); target.addStaleListener(targetStaleListener); validationStatus.addValueChangeListener(validationStatusChangeListener); }
public void dispose () { for ( final IObservableValue v : this.values ) { v.removeValueChangeListener ( Entry.this ); } }
/** * Returns the value of the property on the specified source object * * @param source * the property source * @return the current value of the source's value property * @noreference This method is not intended to be referenced by clients. * @since 1.3 */ protected T doGetValue(S source) { IObservableValue<T> observable = observe(source); try { return observable.getValue(); } finally { observable.dispose(); } }
protected StringSplitListObservable ( final IObservableValue value, final String delimiter, final String pattern, final Object valueType ) { super ( value.getRealm (), new LinkedList<Object> (), valueType ); this.value = value; this.pattern = pattern; this.delimiter = delimiter; value.addValueChangeListener ( this.changeListener ); value.addStaleListener ( this.staleListener ); value.addDisposeListener ( this.disposeListener ); }
protected void firstListenerAdded() { cachedValue = doGetValue(); dateObservable.addChangeListener(privateInterface); dateObservable.addStaleListener(privateInterface); timeObservable.addChangeListener(privateInterface); timeObservable.addStaleListener(privateInterface); }
/** * @param target * @param validationStatus */ public ValidatedObservableMap(final IObservableMap target, final IObservableValue validationStatus) { super(target.getRealm(), new HashMap(target)); Assert.isNotNull(validationStatus, "Validation status observable cannot be null"); //$NON-NLS-1$ Assert .isTrue(target.getRealm().equals(validationStatus.getRealm()), "Target and validation status observables must be on the same realm"); //$NON-NLS-1$ this.target = target; this.validationStatus = validationStatus; target.addMapChangeListener(targetChangeListener); target.addStaleListener(targetStaleListener); validationStatus.addValueChangeListener(validationStatusChangeListener); }
private Object addDetailObservable(Object masterElement, int index) { DetailEntry detailEntry = (DetailEntry) masterDetailMap .get(masterElement); if (detailEntry != null) { // If we already have a detail observable for the given // masterElement, we increment the reference count. detailEntry.masterReferenceCount++; detailList.add(index, detailEntry.detailObservable); return detailEntry.detailObservable.getValue(); } IObservableValue detail = createDetailObservable(masterElement); masterDetailMap.put(masterElement, new DetailEntry(detail)); detailList.add(index, detail); if (hasListeners()) { detail.addValueChangeListener(detailValueListener); detail.addStaleListener(detailStaleListener); if (detail.isStale()) { staleDetailObservables.add(detail); } } return detail.getValue(); }
@Override protected Object calculate () { return ! ( (Boolean)this.value.getValue () ); } }
/** * Constructs a new instance bound to the given * <code>ISWTObservableValue</code> and configured to fire change events * once there have been no value changes in the observable for * <code>delay</code> milliseconds. * * @param delayMillis * @param observable * @throws IllegalArgumentException * if <code>updateEventType</code> is an incorrect type. */ public DelayedObservableValue(int delayMillis, IObservableValue observable) { super(observable.getRealm()); this.delay = delayMillis; this.observable = observable; observable.addValueChangeListener(this); observable.addStaleListener(this); cachedValue = doGetValue(); }
private void recompute() { if (isDirty) { Map<Binding, IStatus> newContents = new HashMap<>(); for (Binding binding : bindings) { IObservableValue<IStatus> validationError = binding.getValidationStatus(); dependencies.add(validationError); validationError.addChangeListener(markDirtyChangeListener); IStatus validationStatusValue = validationError.getValue(); newContents.put(binding, validationStatusValue); } wrappedMap.putAll(newContents); isDirty = false; } }
protected synchronized void firstListenerAdded() { for (int i = 0; i < detailList.size(); i++) { IObservableValue detail = (IObservableValue) detailList.get(i); detail.addValueChangeListener(detailValueListener); detail.addStaleListener(detailStaleListener); if (detail.isStale()) { staleDetailObservables.add(detail); } } }
@Override public IObservableValue observeDetail(IObservableValue master) { Object valueType = getValueType(); if (valueType == null) valueType = inferValueType(master.getValueType()); return MasterDetailObservables.detailValue(master, valueFactory(master .getRealm()), valueType); }
@Override public void run() { validationStatusObservable.setValue(status); } });
@Override public void call(Void value) { w.dispose(); } });
private void setValidationStatus(final IStatus status) { validationStatusObservable.getRealm().exec(new Runnable() { @Override public void run() { validationStatusObservable.setValue(status); } }); }
public synchronized void dispose() { super.dispose(); if (outerObservableValue != null) { outerObservableValue.removeValueChangeListener(outerChangeListener); } if (innerObservableValue != null) { innerObservableValue.removeValueChangeListener(innerChangeListener); innerObservableValue.dispose(); } outerObservableValue = null; outerChangeListener = null; currentOuterValue = null; factory = null; innerObservableValue = null; innerChangeListener = null; }
private void statusProviderChanged() { currentStatusProvider = (ValidationStatusProvider) aggregateStatusProvider .getValue(); if (currentStatusProvider != null) { currentStatus = currentStatusProvider .getValidationStatus().getValue(); } else { currentStatus = null; } currentStatusStale = aggregateStatusProvider.isStale(); handleStatusChanged(); }
protected void hookListener(final Object addedKey) { final IObservableValue detailValue = getDetailObservableValue(addedKey); detailValue.addValueChangeListener(new IValueChangeListener() { public void handleValueChange(ValueChangeEvent event) { if (!event.getObservableValue().isStale()) { staleDetailObservables.remove(detailValue); } fireSingleChange(addedKey, event.diff.getOldValue(), event.diff.getNewValue()); } }); detailValue.addStaleListener(detailStaleListener); }
/** * Returns the type of the value from {@link #doGetValue()}, i.e. * String.class * * @see org.eclipse.core.databinding.observable.value.IObservableValue#getValueType() */ public Object getValueType() { return observable.getValueType(); }