/** * @param target * @param valueType */ public DuplexingObservableValue(IObservableList target, Object valueType) { super(target.getRealm()); this.target = target; this.valueType = valueType; }
/** * @param list */ public ListToSetAdapter(IObservableList list) { super(list.getRealm(), new HashSet(), list.getElementType()); this.list = list; wrappedSet.addAll(list); this.list.addListChangeListener(listener); }
/** * Constructs a MultiList belonging to the given realm, and backed by the * given observable lists. * * @param realm * the observable's realm * @param lists * the array of observable lists backing this MultiList * @param elementType * element type of the constructed list. */ public MultiList(Realm realm, IObservableList[] lists, Object elementType) { super(realm); this.lists = lists; this.elementType = elementType; for (int i = 0; i < lists.length; i++) { Assert .isTrue(realm.equals(lists[i].getRealm()), "All source lists in a MultiList must belong to the same realm"); //$NON-NLS-1$ } }
public void updateModelToTarget() { final IObservableList modelList = (IObservableList) getModel(); modelList.getRealm().exec(new Runnable() { public void run() { ListDiff diff = Diffs.computeListDiff(Collections.EMPTY_LIST, modelList); doUpdate(modelList, (IObservableList) getTarget(), diff, modelToTarget, true, true); } }); }
public void updateTargetToModel() { final IObservableList targetList = (IObservableList) getTarget(); targetList.getRealm().exec(new Runnable() { public void run() { ListDiff diff = Diffs.computeListDiff(Collections.EMPTY_LIST, targetList); doUpdate(targetList, (IObservableList) getModel(), diff, targetToModel, true, true); } }); }
@Override public void updateModelToTarget() { final IObservableList modelList = (IObservableList) getModel(); modelList.getRealm().exec(new Runnable() { @Override public void run() { ListDiff diff = Diffs.computeListDiff(Collections.EMPTY_LIST, modelList); doUpdate(modelList, (IObservableList) getTarget(), diff, modelToTarget, true, true); } }); }
@Override public void updateTargetToModel() { final IObservableList targetList = (IObservableList) getTarget(); targetList.getRealm().exec(new Runnable() { @Override public void run() { ListDiff diff = Diffs.computeListDiff(Collections.EMPTY_LIST, targetList); doUpdate(targetList, (IObservableList) getModel(), diff, targetToModel, true, true); } }); }
@Override public void updateTargetToModel() { target.getRealm().exec(() -> { ListDiff<T> diff = Diffs.computeListDiff(Collections.emptyList(), target); doUpdate(target, model, diff, targetToModel, true, true); }); }
@Override public void updateModelToTarget() { model.getRealm().exec(() -> { ListDiff<M> diff = Diffs.computeListDiff(Collections.emptyList(), model); doUpdate(model, target, diff, modelToTarget, true, true); }); }
/** * @param target * @param validationStatus */ public ValidatedObservableList(final IObservableList<E> target, final IObservableValue<IStatus> validationStatus) { super(target.getRealm(), new ArrayList<>(target), target.getElementType()); 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.addListChangeListener(targetChangeListener); target.addStaleListener(targetStaleListener); validationStatus.addValueChangeListener(validationStatusChangeListener); }
/** * @param target * @param validationStatus */ public ValidatedObservableList(final IObservableList target, final IObservableValue validationStatus) { super(target.getRealm(), new ArrayList(target), target.getElementType()); 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.addListChangeListener(targetChangeListener); target.addStaleListener(targetStaleListener); validationStatus.addValueChangeListener(validationStatusChangeListener); }
/** * @param target * @param validationStatus */ public ValidatedObservableList(final IObservableList target, final IObservableValue validationStatus) { super(target.getRealm(), new ArrayList(target), target.getElementType()); 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.addListChangeListener(targetChangeListener); target.addStaleListener(targetStaleListener); validationStatus.addValueChangeListener(validationStatusChangeListener); }
/** * @since 1.4 */ @Override public <V extends S> IObservableList<T> observeDetail(IObservableList<V> master) { return MasterDetailObservables.detailValues(master, valueFactory(master.getRealm()), getValueType()); }
/** * @since 1.4 */ @Override public <V extends S> IObservableList<T> observeDetail(IObservableList<V> master) { return MasterDetailObservables.detailValues(master, valueFactory(master.getRealm()), getValueType()); }
/** * @param masterList * @param valueProperty */ public ListDelegatingValueObservableList(IObservableList<T> masterList, DelegatingValueProperty<S, E> valueProperty) { super(masterList.getRealm()); this.masterList = masterList; this.detailProperty = valueProperty; this.cache = new DelegatingCache<S, T, E>(getRealm(), valueProperty) { @Override void handleValueChange(T masterElement, E oldValue, E newValue) { fireListChange(indicesOf(masterElement), oldValue, newValue); } }; cache.addAll(masterList); masterList.addListChangeListener(masterListener); masterList.addStaleListener(staleListener); }
/** * @param masterList * @param valueProperty */ public ListDelegatingValueObservableList(IObservableList<T> masterList, DelegatingValueProperty<S, E> valueProperty) { super(masterList.getRealm()); this.masterList = masterList; this.detailProperty = valueProperty; this.cache = new DelegatingCache<S, T, E>(getRealm(), valueProperty) { @Override void handleValueChange(T masterElement, E oldValue, E newValue) { fireListChange(indicesOf(masterElement), oldValue, newValue); } }; cache.addAll(masterList); masterList.addListChangeListener(masterListener); masterList.addStaleListener(staleListener); }
/** * * @param masterList * @param detailFactory * @param detailType */ public ListDetailValueObservableList(IObservableList masterList, IObservableFactory detailFactory, Object detailType) { super(masterList.getRealm()); this.masterList = masterList; this.detailFactory = detailFactory; this.detailType = detailType; this.detailList = new ArrayList(); // Add change/stale/dispose listeners on the master list. masterList.addListChangeListener(masterListListener); masterList.addStaleListener(masterStaleListener); masterList.addDisposeListener(new IDisposeListener() { public void handleDispose(DisposeEvent event) { ListDetailValueObservableList.this.dispose(); } }); ListDiff initMasterDiff = Diffs.computeListDiff(Collections.EMPTY_LIST, masterList); handleMasterListChange(initMasterDiff); }
/** * @param masterList * @param valueProperty */ public ListSimpleValueObservableList(IObservableList<M> masterList, SimpleValueProperty<S, T> valueProperty) { super(masterList.getRealm()); this.masterList = masterList; this.detailProperty = valueProperty; ISimplePropertyListener<S, ValueDiff<? extends T>> listener = event -> { if (!isDisposed() && !updating) { getRealm().exec(() -> { @SuppressWarnings("unchecked") M source = (M) event.getSource(); if (event.type == SimplePropertyEvent.CHANGE) { notifyIfChanged(source); } else if (event.type == SimplePropertyEvent.STALE) { boolean wasStale = !staleElements.isEmpty(); staleElements.add(source); if (!wasStale) fireStale(); } }); } }; this.detailListener = detailProperty.adaptListener(listener); }
@Override protected void postInit() { if (modelToTarget.getUpdatePolicy() == UpdateListStrategy.POLICY_UPDATE) { model.getRealm().exec(() -> { model.addListChangeListener(modelChangeListener); updateModelToTarget(); }); } else { modelChangeListener = null; } if (targetToModel.getUpdatePolicy() == UpdateListStrategy.POLICY_UPDATE) { target.getRealm().exec(() -> { target.addListChangeListener(targetChangeListener); if (modelToTarget.getUpdatePolicy() == UpdateListStrategy.POLICY_NEVER) { // we have to sync from target to model, if the other // way round (model to target) is forbidden // (POLICY_NEVER) updateTargetToModel(); } else { validateTargetToModel(); } }); } else { targetChangeListener = null; } }
private void updateInnerObservableList() { if (innerObservableList != null) { innerObservableList.removeListChangeListener(innerChangeListener); innerObservableList.dispose(); } currentOuterValue = outerObservableValue.getValue(); if (currentOuterValue == null) { innerObservableList = null; wrappedList = Collections.EMPTY_LIST; } else { ObservableTracker.setIgnore(true); try { innerObservableList = (IObservableList) factory .createObservable(currentOuterValue); } finally { ObservableTracker.setIgnore(false); } DetailObservableHelper.warnIfDifferentRealms(getRealm(), innerObservableList.getRealm()); wrappedList = innerObservableList; if (detailType != null) { Object innerValueType = innerObservableList.getElementType(); Assert.isTrue(getElementType().equals(innerValueType), "Cannot change value type in a nested observable list"); //$NON-NLS-1$ } innerObservableList.addListChangeListener(innerChangeListener); } }