Attachment #105098 for bug #233191




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 218269)
 *     Ovidio Mallo - bug 233191
 ******************************************************************************/

package org.eclipse.core.tests.databinding.validation;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.databinding.validation.MultiValidator;


public class MultiValidatorTest extends AbstractDefaultRealmTestCase {
	private WritableValue dependency;
	private TestMultiValidator validator;
	private IObservableValue validationStatus;

	protected void setUp() throws Exception {
		super.setUp();
		dependency = new WritableValue(null, IStatus.class);
		validator = new TestMultiValidator() {
			protected IStatus validate() {
				return (IStatus) dependency.getValue();
			}


	public void testGetValidationStatus_ExceptionThrownYieldsErrorStatus() {
		final RuntimeException e = new RuntimeException("message");
		validator = new TestMultiValidator() {
			protected IStatus validate() {
				throw e;
			}

		assertEquals(target.getValue(), validated.getValue());
		assertFalse(validated.isStale());
	}

	public void testEnterExitStale_ValidationStatusStaleness() {
		StaleCounter staleCounter = new StaleCounter();
		validationStatus.addStaleListener(staleCounter);

		assertEquals(0, staleCounter.count);

		validator.enterStaleDelegate();
		assertEquals(1, staleCounter.count);
		assertTrue(validationStatus.isStale());

		validator.exitStaleDelegate((IStatus) validationStatus.getValue());
		assertFalse(validationStatus.isStale());
	}

	public void testEnterExitStale_ValidationStatusValue() {
		validator.enterStaleDelegate();
		IStatus status = ValidationStatus.error("done");
		validator.exitStaleDelegate(status);
		assertSame(status, validationStatus.getValue());
	}

	/**
	 * Simple extension of the MultiValidator class which is functionally
	 * equivalent while making some methods accessible to the unit tests.
	 */
	private static abstract class TestMultiValidator extends MultiValidator {

		void enterStaleDelegate() {
			enterStale();
		}

		void exitStaleDelegate(IStatus status) {
			exitStale(status);
		}
	}

	private static class StaleCounter implements IStaleListener {

		int count;

		public void handleStale(StaleEvent event) {
			count++;
		}
	}
}

Lines 64-68 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/QueueTest.java (-1 / +10 lines)
64	assertEquals("moo", queue.dequeue());	64	assertEquals("moo", queue.dequeue());
65	assertTrue(queue.isEmpty());	65	assertTrue(queue.isEmpty());
66	}	66	}
67		67
		68	public void testClear() {
		69	assertTrue(queue.isEmpty());
		70	queue.enqueue("foo");
		71	assertFalse(queue.isEmpty());
		72	queue.clear();
		73	assertTrue(queue.isEmpty());
		74	queue.clear();
		75	assertTrue(queue.isEmpty());
		76	}
68	}	77	}

Lines 203-208 Link Here

(-)src/org/eclipse/jface/tests/databinding/scenarios/PropertyScenarios.java (+8 lines)
203	String remainingChars = modelValue.substring(1);	203	String remainingChars = modelValue.substring(1);
204	return firstChar.toUpperCase() + remainingChars.toLowerCase();	204	return firstChar.toUpperCase() + remainingChars.toLowerCase();
205	}	205	}
		206
		207	public boolean isAsync() {
		208	return false;
		209	}
206	};	210	};
207	IConverter converter2 = new IConverter() {	211	IConverter converter2 = new IConverter() {
208	public Object getFromType() {	212	public Object getFromType() {
Lines 216-221 Link Here
216	public Object convert(Object fromObject) {	220	public Object convert(Object fromObject) {
217	return ((String) fromObject).toUpperCase();	221	return ((String) fromObject).toUpperCase();
218	}	222	}
		223
		224	public boolean isAsync() {
		225	return false;
		226	}
219	};	227	};
220		228
221	getDbc().bindValue(SWTObservables.observeText(text, SWT.Modify),	229	getDbc().bindValue(SWTObservables.observeText(text, SWT.Modify),

Lines 16-24 Link Here

(-)src/org/eclipse/core/tests/databinding/UpdateValueStrategyTest.java (-1 / +45 lines)
16	import java.util.Date;	16	import java.util.Date;
17		17
18	import org.eclipse.core.databinding.UpdateValueStrategy;	18	import org.eclipse.core.databinding.UpdateValueStrategy;
		19	import org.eclipse.core.databinding.conversion.Converter;
		20	import org.eclipse.core.databinding.conversion.IConverter;
19	import org.eclipse.core.databinding.observable.value.IObservableValue;	21	import org.eclipse.core.databinding.observable.value.IObservableValue;
20	import org.eclipse.core.databinding.observable.value.WritableValue;	22	import org.eclipse.core.databinding.observable.value.WritableValue;
21	import org.eclipse.core.databinding.validation.IValidator;	23	import org.eclipse.core.databinding.validation.IValidator;
		24	import org.eclipse.core.databinding.validation.IValidator2;
		25	import org.eclipse.core.databinding.validation.ValidationStatus;
22	import org.eclipse.core.internal.databinding.validation.NumberToByteValidator;	26	import org.eclipse.core.internal.databinding.validation.NumberToByteValidator;
23	import org.eclipse.core.internal.databinding.validation.NumberToDoubleValidator;	27	import org.eclipse.core.internal.databinding.validation.NumberToDoubleValidator;
24	import org.eclipse.core.internal.databinding.validation.NumberToFloatValidator;	28	import org.eclipse.core.internal.databinding.validation.NumberToFloatValidator;
Lines 33-38 Link Here
33	import org.eclipse.core.internal.databinding.validation.StringToIntegerValidator;	37	import org.eclipse.core.internal.databinding.validation.StringToIntegerValidator;
34	import org.eclipse.core.internal.databinding.validation.StringToLongValidator;	38	import org.eclipse.core.internal.databinding.validation.StringToLongValidator;
35	import org.eclipse.core.internal.databinding.validation.StringToShortValidator;	39	import org.eclipse.core.internal.databinding.validation.StringToShortValidator;
		40	import org.eclipse.core.runtime.IStatus;
36	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	41	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
37		42
38	/**	43	/**
Lines 138-144 Link Here
138		143
139	assertSame(validator,strategy.validator);	144	assertSame(validator,strategy.validator);
140	}	145	}
141		146
		147	public void testIsAsync_DefaultDelegatesToValidatorsAndConverter() throws Exception {
		148	IValidator2 asyncValidator = new IValidator2() {
		149	public IStatus validate(Object value) {
		150	return ValidationStatus.ok();
		151	}
		152
		153	public boolean isAsync() {
		154	return true;
		155	}
		156	};
		157
		158	IConverter asyncConverter = new Converter(null, null) {
		159	public Object convert(Object fromObject) {
		160	return null;
		161	}
		162
		163	public boolean isAsync() {
		164	return true;
		165	}
		166	};
		167
		168	UpdateValueStrategy strategy;
		169
		170	strategy = new UpdateValueStrategy();
		171	assertFalse(strategy.isAsync());
		172
		173	strategy = new UpdateValueStrategy().setAfterGetValidator(asyncValidator);
		174	assertTrue(strategy.isAsync());
		175
		176	strategy = new UpdateValueStrategy().setConverter(asyncConverter);
		177	assertTrue(strategy.isAsync());
		178
		179	strategy = new UpdateValueStrategy().setAfterConvertValidator(asyncValidator);
		180	assertTrue(strategy.isAsync());
		181
		182	strategy = new UpdateValueStrategy().setBeforeSetValidator(asyncValidator);
		183	assertTrue(strategy.isAsync());
		184	}
		185
142	private void assertDefaultValidator(Class fromType, Class toType, Class validatorType) {	186	private void assertDefaultValidator(Class fromType, Class toType, Class validatorType) {
143	WritableValue source = WritableValue.withValueType(fromType);	187	WritableValue source = WritableValue.withValueType(fromType);
144	WritableValue destination = WritableValue.withValueType(toType);	188	WritableValue destination = WritableValue.withValueType(toType);

Lines 9-24 Link Here

(-)src/org/eclipse/core/tests/databinding/ValueBindingTest.java (-1 / +150 lines)
9	* Brad Reynolds - initial API and implementation	9	* Brad Reynolds - initial API and implementation
10	* Brad Reynolds - bug 116920	10	* Brad Reynolds - bug 116920
11	* Brad Reynolds - bug 164653, 159768	11	* Brad Reynolds - bug 164653, 159768
		12	* Ovidio Mallo - bug 233191
12	******************************************************************************/	13	******************************************************************************/
13		14
14	package org.eclipse.core.tests.databinding;	15	package org.eclipse.core.tests.databinding;
15		16
		17	import java.util.Random;
		18
		19	import org.eclipse.core.databinding.AggregateValidationStatus;
16	import org.eclipse.core.databinding.Binding;	20	import org.eclipse.core.databinding.Binding;
17	import org.eclipse.core.databinding.DataBindingContext;	21	import org.eclipse.core.databinding.DataBindingContext;
18	import org.eclipse.core.databinding.UpdateValueStrategy;	22	import org.eclipse.core.databinding.UpdateValueStrategy;
		23	import org.eclipse.core.databinding.conversion.Converter;
		24	import org.eclipse.core.databinding.conversion.IConverter;
19	import org.eclipse.core.databinding.observable.Diffs;	25	import org.eclipse.core.databinding.observable.Diffs;
20	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;	26	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
21	import org.eclipse.core.databinding.observable.value.IObservableValue;	27	import org.eclipse.core.databinding.observable.value.IObservableValue;
		28	import org.eclipse.core.databinding.observable.value.IValueChangeListener;
		29	import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
22	import org.eclipse.core.databinding.observable.value.ValueDiff;	30	import org.eclipse.core.databinding.observable.value.ValueDiff;
23	import org.eclipse.core.databinding.observable.value.WritableValue;	31	import org.eclipse.core.databinding.observable.value.WritableValue;
24	import org.eclipse.core.databinding.validation.IValidator;	32	import org.eclipse.core.databinding.validation.IValidator;
Lines 27-32 Link Here
27	import org.eclipse.core.runtime.IStatus;	35	import org.eclipse.core.runtime.IStatus;
28	import org.eclipse.core.runtime.MultiStatus;	36	import org.eclipse.core.runtime.MultiStatus;
29	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	37	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
		38	import org.eclipse.swt.widgets.Display;
30		39
31	/**	40	/**
32	* @since 1.1	41	* @since 1.1
Lines 228-234 Link Here
228	target.fireValueChange(Diffs.createValueDiff("", ""));	237	target.fireValueChange(Diffs.createValueDiff("", ""));
229	assertEquals("update does not occur", count, strategy.afterGetCount);	238	assertEquals("update does not occur", count, strategy.afterGetCount);
230	}	239	}
231		240
		241	public void testIsAsync() throws Exception {
		242	UpdateValueStrategy asyncStrategy = new UpdateValueStrategy() {
		243	public boolean isAsync() {
		244	return true;
		245	}
		246	};
		247
		248	assertFalse(dbc.bindValue(target, model, null, null).isAsync());
		249	assertTrue(dbc.bindValue(target, model, asyncStrategy, null).isAsync());
		250	assertTrue(dbc.bindValue(target, model, null, asyncStrategy).isAsync());
		251	assertTrue(dbc.bindValue(target, model, asyncStrategy, asyncStrategy)
		252	.isAsync());
		253	}
		254
		255	public void testAsyncExecutesInSeparateThread() throws Exception {
		256	final Thread realmThread = Thread.currentThread();
		257
		258	IConverter asyncConverter = new Converter(null, null) {
		259	public Object convert(Object fromObject) {
		260	assertNotSame(Thread.currentThread(), realmThread);
		261	return null;
		262	}
		263
		264	public boolean isAsync() {
		265	return true;
		266	}
		267	};
		268
		269	UpdateValueStrategy targetToModel = new UpdateValueStrategy();
		270	targetToModel.setConverter(asyncConverter);
		271	UpdateValueStrategy modelToTarget = new UpdateValueStrategy();
		272	modelToTarget.setConverter(asyncConverter);
		273
		274	Binding binding = dbc.bindValue(target, model, targetToModel, modelToTarget);
		275
		276	assertTrue(binding.isAsync());
		277
		278	binding.updateTargetToModel();
		279	binding.updateModelToTarget();
		280	}
		281
		282	public void testAsyncUpdateSerialization() throws Exception {
		283	UpdateValueStrategy targetToModel = new UpdateValueStrategy();
		284	targetToModel.setConverter(asyncConverter());
		285
		286	UpdateValueStrategy modelToTarget = new UpdateValueStrategy();
		287	modelToTarget.setConverter(asyncConverter());
		288
		289	dbc.bindValue(target, model, targetToModel, modelToTarget);
		290
		291	// Write to the target.
		292	for (int i = 0; i <= 10; i++) {
		293	target.setValue(String.valueOf(i));
		294	}
		295	awaitPendingValidations(dbc);
		296	// Check that the updates to the model have been correctly serialized.
		297	assertEquals("10", model.getValue());
		298
		299	// Write to the model.
		300	for (int i = 0; i <= 10; i++) {
		301	model.setValue(String.valueOf(i));
		302	}
		303	awaitPendingValidations(dbc);
		304	// Check that the updates to the target have been correctly serialized.
305	assertEquals("10", target.getValue());
306
307	// Alternatively write to the target and model.
308	for (int i = 0; i <= 10; i++) {
309	if (i % 2 == 0) {
310	target.setValue(String.valueOf(i));
311	} else {
312	model.setValue(String.valueOf(i));
313	}
314	}
315	awaitPendingValidations(dbc);
316	// Check that target and model end up having the correct value.
317	assertEquals("10", target.getValue());
318	assertEquals("10", model.getValue());
319	}
320
321	public void testDisposeCancelsPendingUpdates() throws Exception {
322	UpdateValueStrategy targetToModel = new UpdateValueStrategy();
323	targetToModel.setConverter(asyncConverter());
324
325	final Binding binding = dbc.bindValue(target, model, targetToModel,
326	null);
327
328	model.addValueChangeListener(new IValueChangeListener() {
329	public void handleValueChange(ValueChangeEvent event) {
330	fail("No update should get to the model if we dispose the Binding.");
331	}
332	});
333
334	// Note that neither v1 nor v2 should make their way to the model since
335	// we only dispatch the events on the UI thread by calling the method
336	// awaitPendingValidations(...) below after having disposed the binding.
337	target.setValue("v1");
338	binding.dispose();
339	target.setValue("v2");
340
341	awaitPendingValidations(dbc);
342	}
343
344	private void awaitPendingValidations(DataBindingContext dbc) {
345	AggregateValidationStatus validation = new AggregateValidationStatus(
346	dbc, AggregateValidationStatus.MERGED);
347
348	while (validation.isStale()) {
349	// By dispatching on the Display, we get the pending runnables
350	// executed on the Realm belonging to the Display.
351	Display display = Display.getCurrent();
352	while (display.readAndDispatch()) {
353	// just dispatch
354	}
355	if (validation.isStale()) {
356	display.sleep();
357	}
358	}
359	}
360
232	private IValidator warningValidator() {	361	private IValidator warningValidator() {
233	return new IValidator() {	362	return new IValidator() {
234	public IStatus validate(Object value) {	363	public IStatus validate(Object value) {
Lines 261-266 Link Here
261	};	390	};
262	}	391	}
263		392
		393	private static IConverter asyncConverter() {
		394	return new Converter(String.class, String.class) {
		395
		396	private final Random random = new Random(System.currentTimeMillis());
		397
		398	public Object convert(Object fromObject) {
		399	try {
		400	Thread.sleep(random.nextInt(100));
		401	} catch (InterruptedException e) {
		402	// do nothing
		403	}
		404	return fromObject;
		405	}
		406
		407	public boolean isAsync() {
		408	return true;
		409	}
		410	};
		411	}
		412
264	private static class ObservableValueStub extends AbstractObservableValue {	413	private static class ObservableValueStub extends AbstractObservableValue {
265	protected Object doGetValue() {	414	protected Object doGetValue() {
266	// do nothing	415	// do nothing




/*******************************************************************************
 * Copyright (c) 2007 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.internal.databinding.UpdateValidationObservableValue;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;

/**
 * @since 1.2
 */
public class UpdateValidationObservableValueTest extends
		AbstractDefaultRealmTestCase {

	public static Test suite() {
		TestSuite suite = new TestSuite(
				UpdateValidationObservableValueTest.class.getName());
		suite.addTestSuite(UpdateValidationObservableValueTest.class);
		suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));
		return suite;
	}

	public void testStaleness() {
		UpdateValidationObservableValueStub observable = new UpdateValidationObservableValueStub(
				Realm.getDefault());

		ValueChangeCounter valueChangeCounter = new ValueChangeCounter();
		observable.addValueChangeListener(valueChangeCounter);

		StaleCounter staleCounter = new StaleCounter();
		observable.addStaleListener(staleCounter);

		assertEquals(0, valueChangeCounter.count);
		assertEquals(0, staleCounter.count);
		assertFalse(observable.isStale());

		observable.setStale(true);
		assertEquals(0, valueChangeCounter.count);
		assertEquals(1, staleCounter.count);
		assertTrue(observable.isStale());

		observable.setStale(false);
		assertEquals(1, valueChangeCounter.count);
		assertEquals(1, staleCounter.count);
		assertFalse(observable.isStale());
	}

	/* package */static class Delegate extends
			AbstractObservableValueContractDelegate {

		public IObservableValue createObservableValue(Realm realm) {
			return new UpdateValidationObservableValueStub(realm);
		}

		public void change(IObservable observable) {
			IObservableValue observableValue = (IObservableValue) observable;
			observableValue.setValue(createValue(observableValue));
		}

		public void setStale(IObservable observable, boolean stale) {
			((UpdateValidationObservableValueStub) observable).setStale(stale);
		}

		public Object getValueType(IObservableValue observable) {
			return IStatus.class;
		}

		public Object createValue(IObservableValue observable) {
			IStatus status = (IStatus) observable.getValue();
			return ValidationStatus.error(status.getMessage() + "a");
		}
	}

	private static class UpdateValidationObservableValueStub extends
			UpdateValidationObservableValue {

		private boolean stale = false;

		public UpdateValidationObservableValueStub(Realm realm) {
			super(realm);
		}

		public boolean isStale() {
			ObservableTracker.getterCalled(this);
			return stale;
		}

		public void setStale(boolean stale) {
			this.stale = stale;
			updateStaleness();
		}
	}

	private static class ValueChangeCounter implements IValueChangeListener {

		int count;

		public void handleValueChange(ValueChangeEvent event) {
			count++;
		}
	}

	private static class StaleCounter implements IStaleListener {

		int count;

		public void handleStale(StaleEvent event) {
			count++;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding;

import java.util.ArrayList;

import junit.framework.TestCase;

import org.eclipse.core.internal.databinding.UpdateExecutor;
import org.eclipse.core.internal.databinding.UpdateRunnable;

/**
 * @since 1.2
 */
public class UpdateExecutorTest extends TestCase {

	public void testSyncExecutesInSameThread() throws Throwable {
		UpdateExecutor executor = new UpdateExecutor(false, null);

		final Thread mainThread = Thread.currentThread();
		TestUpdateRunnable update = new TestUpdateRunnable() {
			public void doRun() {
				assertSame(mainThread, Thread.currentThread());
				notifyDone();
			}
		};

		executor.execute(update, false);

		awaitPendingUpdates(executor);
		assertNotFailed(update);
	}

	public void testAsyncExecutesInSeparateThread() throws Throwable {
		UpdateExecutor executor = new UpdateExecutor(true, null);

		final Thread mainThread = Thread.currentThread();
		TestUpdateRunnable update = new TestUpdateRunnable() {
			public void doRun() {
				assertNotSame(mainThread, Thread.currentThread());
				notifyDone();
			}
		};

		executor.execute(update, false);

		awaitPendingUpdates(executor);
		assertNotFailed(update);
	}

	public void testHasPendingUpdates() throws Throwable {
		// Test for both, synchronous and asynchronous executions.
		testHasPendingUpdates(false);
		testHasPendingUpdates(true);
	}

	private static void testHasPendingUpdates(boolean isAsync) throws Throwable {
		final UpdateExecutor executor = new UpdateExecutor(isAsync, null);

		TestUpdateRunnable update = new TestUpdateRunnable() {
			public void doRun() {
				assertTrue(executor.hasPendingUpdates());
				notifyDone();
				assertFalse(executor.hasPendingUpdates());
			}
		};

		assertFalse(executor.hasPendingUpdates());
		executor.execute(update, false);

		awaitPendingUpdates(executor);
		assertNotFailed(update);
	}

	public void testSchedulingEventCallbackInvoked() throws Throwable {
		// Test for both, synchronous and asynchronous executions.
		testSchedulingEventCallbackInvoked(false);
		testSchedulingEventCallbackInvoked(true);
	}

	private static void testSchedulingEventCallbackInvoked(boolean isAsync)
			throws Throwable {
		final SchedulingEventCallbackCounter callbackCounter = new SchedulingEventCallbackCounter();
		UpdateExecutor executor = new UpdateExecutor(isAsync, callbackCounter);

		assertEquals(0, callbackCounter.count);

		TestUpdateRunnable update = new TestUpdateRunnable() {
			public void doRun() {
				// At this point, we must already have received the scheduling
				// event of having started this update.
				assertEquals(1, callbackCounter.count);
				notifyDone();
				// At this point, we must have received the scheduling event
				// about the update having terminated.
				assertEquals(2, callbackCounter.count);
			}
		};

		executor.execute(update, false);

		awaitPendingUpdates(executor);
		assertNotFailed(update);
	}

	public void testAsyncExecuteInOrder() throws Throwable {
		UpdateExecutor executor = new UpdateExecutor(true, null);

		final ArrayList updateList = new ArrayList();
		for (int i = 0; i < 10; i++) {
			updateList.add(new TestUpdateRunnable() {
				public void doRun() {
					assertSame(updateList.remove(0), this);
					notifyDone();
				}
			});
		}

		// The original list is modified by the updates, so we make a copy.
		ArrayList updateListCopy = new ArrayList(updateList);
		for (int i = 0; i < updateListCopy.size(); i++) {
			UpdateRunnable update = (UpdateRunnable) updateListCopy.get(i);
			executor.execute(update, false);
		}

		awaitPendingUpdates(executor);
		for (int i = 0; i < updateListCopy.size(); i++) {
			assertNotFailed((TestUpdateRunnable) updateListCopy.get(i));
		}
	}

	public void testCancelPendingUpdates() throws Throwable {
		// Test for both, canceling and not canceling pending updates.
		testCancelPendingUpdates(false);
		testCancelPendingUpdates(true);
	}

	private void testCancelPendingUpdates(boolean doCancel) throws Throwable {
		UpdateExecutor executor = new UpdateExecutor(true, null);

		// In order to reliably ensure that update1 has not already terminated
		// when we request its canceling, we start the two updates while holding
		// a lock which is also tried to be acquired by update1.
		synchronized (this) {
			TestUpdateRunnable update1 = new TestUpdateRunnable() {
				public void doRun() {
					synchronized (UpdateExecutorTest.this) {
						// just try to acquire the lock
					}
					notifyDone();
				}
			};

			executor.execute(update1, false);

			assertFalse(update1.isCanceled());
			executor.execute(new TestUpdateRunnable(), doCancel);
			assertEquals(doCancel, update1.isCanceled());
		}
	}

	public void testTerminateCancelsPendingUpdates() throws Throwable {
		UpdateExecutor executor = new UpdateExecutor(true, null);

		// In order to reliably ensure that the update has not already
		// terminated when we request its canceling, we start the two updates
		// while holding a lock which is also tried to be acquired by the
		// update.
		synchronized (this) {
			TestUpdateRunnable update = new TestUpdateRunnable() {
				public void doRun() {
					synchronized (UpdateExecutorTest.this) {
						// just try to acquire the lock
					}
					notifyDone();
				}
			};

			executor.execute(update, false);

			assertFalse(update.isCanceled());
			executor.terminate();
			assertTrue(update.isCanceled());
		}
	}

	private static void awaitPendingUpdates(UpdateExecutor executor) {
		while (executor.hasPendingUpdates()) {
			try {
				// avoid continuous polling
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// just go ahead
			}
		}
	}

	private static void assertNotFailed(TestUpdateRunnable update)
			throws Throwable {
		if (update.throwable != null) {
			throw update.throwable;
		}
	}

	/**
	 * Simple extension of an UpdateRunnable which catches any Throwable thrown
	 * during the execution of the {@link #run()} method and stores it in a
	 * class field for later querying. We do this to be able to use JUnit
	 * assertions from within the run method since when running an
	 * UpdateRunnable asynchronously, the UpdateExecutor class executes it from
	 * within a Job which would otherwise swallow all Throwables.
	 * 
	 * TODO Maybe, this could be done more elegantly?
	 */
	private static class TestUpdateRunnable extends UpdateRunnable {

		public Throwable throwable = null;

		public void run() {
			try {
				doRun();
			} catch (Throwable t) {
				throwable = t;
				notifyDone();
			}
		}

		public void doRun() {
			// do nothing
		}
	}

	private static class SchedulingEventCallbackCounter implements Runnable {

		public int count = 0;

		public void run() {
			count++;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.jface.tests.databinding.wizard;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.ValidationStatusProvider;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Observables;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.internal.commands.util.Util;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.databinding.wizard.WizardPageSupport;
import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.widgets.Composite;

/**
 * @since 1.2
 */
public class WizardPageSupportTest extends AbstractSWTTestCase {

	public void testPageCompleteOnValidationStaleness() {
		IWizardPage page = new WizardPage("Page") {
			public void createControl(Composite parent) {
				setControl(parent);

				ValidationObservable validation = new ValidationObservable();

				DataBindingContext dbc = new DataBindingContext();
				dbc.addValidationStatusProvider(new ValidationProvider(
						validation));

				WizardPageSupport.create(this, dbc);

				assertTrue(isPageComplete());

				validation.setStale(true);
				assertFalse(isPageComplete());

				validation.setStale(false);
				assertTrue(isPageComplete());
			}
		};

		loadWizardPage(page);
	}

	private void loadWizardPage(IWizardPage page) {
		Wizard wizard = new Wizard() {
			public boolean performFinish() {
				return true;
			}
		};
		wizard.addPage(page);

		WizardDialog dialog = new WizardDialog(getShell(), wizard);
		dialog.create();
	}

	private static class ValidationObservable extends AbstractObservableValue {

		private Object value = ValidationStatus.ok();

		private boolean stale = false;

		public ValidationObservable() {
			super(Realm.getDefault());
		}

		protected Object doGetValue() {
			return value;
		}

		protected void doSetValue(Object value) {
			Object oldValue = this.value;
			this.value = value;
			if (!Util.equals(oldValue, value)) {
				fireValueChange(Diffs.createValueDiff(oldValue, value));
			}
		}

		public boolean isStale() {
			return stale;
		}

		public void setStale(boolean stale) {
			if (this.stale != stale) {
				this.stale = stale;
				if (stale) {
					fireStale();
				} else {
					fireValueChange(Diffs.createValueDiff(value, value));
				}
			}
		}

		public Object getValueType() {
			return IStatus.class;
		}
	}

	private static class ValidationProvider extends ValidationStatusProvider {

		private final IObservableValue validation;

		public ValidationProvider(IObservableValue validation) {
			this.validation = validation;
		}

		public IObservableValue getValidationStatus() {
			return validation;
		}

		public IObservableList getTargets() {
			return Observables.emptyObservableList();
		}

		public IObservableList getModels() {
			return Observables.emptyObservableList();
		}
	}
}

Lines 9-15 Link Here

(-)src/org/eclipse/jface/databinding/wizard/WizardPageSupport.java (-3 / +23 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Boris Bokowski - bug 218269	10	* Boris Bokowski - bug 218269
11	* Matthew Hall - bug 218269	11	* Matthew Hall - bug 218269
12	* Ashley Cambrell - bug 199179	12	* Ashley Cambrell - bug 199179
		13	* Ovidio Mallo - bug 233191
13	*******************************************************************************/	14	*******************************************************************************/
14	package org.eclipse.jface.databinding.wizard;	15	package org.eclipse.jface.databinding.wizard;
15		16
Lines 21-26 Link Here
21	import org.eclipse.core.databinding.observable.ChangeEvent;	22	import org.eclipse.core.databinding.observable.ChangeEvent;
22	import org.eclipse.core.databinding.observable.IChangeListener;	23	import org.eclipse.core.databinding.observable.IChangeListener;
23	import org.eclipse.core.databinding.observable.IObservable;	24	import org.eclipse.core.databinding.observable.IObservable;
		25	import org.eclipse.core.databinding.observable.IStaleListener;
		26	import org.eclipse.core.databinding.observable.StaleEvent;
24	import org.eclipse.core.databinding.observable.list.IListChangeListener;	27	import org.eclipse.core.databinding.observable.list.IListChangeListener;
25	import org.eclipse.core.databinding.observable.list.IObservableList;	28	import org.eclipse.core.databinding.observable.list.IObservableList;
26	import org.eclipse.core.databinding.observable.list.ListChangeEvent;	29	import org.eclipse.core.databinding.observable.list.ListChangeEvent;
Lines 41-46 Link Here
41	* given wizard page, updating the wizard page's completion state and its error	44	* given wizard page, updating the wizard page's completion state and its error
42	* message accordingly.	45	* message accordingly.
43	*	46	*
		47	* <p>
		48	* The completion state of the wizard page will only be set to <code>true</code>
		49	* if <i>all</i> of the following conditions are met:
		50	* <ul>
		51	* <li>The validation result from the data binding context has none of the
		52	* severities {@link IStatus#ERROR} and {@link IStatus#CANCEL}.</li>
		53	* <li>None of the validation status observables of the data binding context is
		54	* stale.</li>
		55	* </ul>
		56	* </p>
		57	*
44	* @noextend This class is not intended to be subclassed by clients.	58	* @noextend This class is not intended to be subclassed by clients.
45	*	59	*
46	* @since 1.1	60	* @since 1.1
Lines 137-142 Link Here
137	handleStatusChanged();	151	handleStatusChanged();
138	}	152	}
139	});	153	});
		154	aggregateStatus.addStaleListener(new IStaleListener() {
		155	public void handleStale(StaleEvent staleEvent) {
		156	handleStatusChanged();
		157	}
		158	});
140	currentStatus = (IStatus) aggregateStatus.getValue();	159	currentStatus = (IStatus) aggregateStatus.getValue();
141	handleStatusChanged();	160	handleStatusChanged();
142	dbc.getValidationStatusProviders().addListChangeListener(	161	dbc.getValidationStatusProviders().addListChangeListener(
Lines 188-194 Link Here
188	} else if (currentStatus != null	207	} else if (currentStatus != null
189	&& currentStatus.getSeverity() != IStatus.OK) {	208	&& currentStatus.getSeverity() != IStatus.OK) {
190	int severity = currentStatus.getSeverity();	209	int severity = currentStatus.getSeverity();
191	wizardPage.setPageComplete((severity & IStatus.CANCEL) != 0);	210	wizardPage.setPageComplete(((severity & IStatus.CANCEL) == 0)
		211	&& !aggregateStatus.isStale());
192	int type;	212	int type;
193	switch (severity) {	213	switch (severity) {
194	case IStatus.OK:	214	case IStatus.OK:
Lines 213-219 Link Here
213	wizardPage.setErrorMessage(null);	233	wizardPage.setErrorMessage(null);
214	wizardPage.setMessage(currentStatus.getMessage(), type);	234	wizardPage.setMessage(currentStatus.getMessage(), type);
215	} else {	235	} else {
216	wizardPage.setPageComplete(true);	236	wizardPage.setPageComplete(!aggregateStatus.isStale());
217	wizardPage.setMessage(null);	237	wizardPage.setMessage(null);
218	wizardPage.setErrorMessage(null);	238	wizardPage.setErrorMessage(null);
219	}	239	}




 *     Brad Reynolds - bug 159768
 *     Boris Bokowski - bug 218269
 *     Matthew Hall - bug 218269
 *     Ovidio Mallo - bug 233191
 *******************************************************************************/

package org.eclipse.core.databinding;

	 * by the time this call returns.
	 */
	public abstract void validateModelToTarget();

	/**
	 * Returns whether the updates performed by this binding are executed
	 * asynchronously.
	 * 
	 * <p>
	 * By default, this method returns <code>false</code>. Subclasses will
	 * typically want to overwrite this method to return whether <i>any</i> of
	 * the binding's update strategies is intended to be run asynchronously.
	 * However, subclasses may always decide not to execute the updates
	 * asynchronously.
	 * </p>
	 * 
	 * @return whether the updates performed by this binding are executed
	 *         asynchronously.
	 */
	public boolean isAsync() {
		return false;
	}

	/**
	 * Disposes of this Binding. Subclasses may extend, but must call super.dispose().
	 */




		}
		return Status.OK_STATUS;
	}

	/**
	 * Returns whether the list update defined by this strategy is intended to
	 * be executed asynchronously.
	 * 
	 * <p>
	 * By default, this method returns <code>true</code> if and only if the
	 * converter associated to this strategy is intended to be executed
	 * asynchronously. Clients may extend without having to call the super
	 * implementation.
	 * </p>
	 * 
	 * <p>
	 * Note that even if this method returns <code>true</code>, there is no
	 * guarantee as of whether the list update will indeed by executed
	 * asynchronously or not.
	 * </p>
	 * 
	 * @return whether the list update defined by this strategy is intended to
	 *         be executed asynchronously.
	 * 
	 * @see IConverter#isAsync()
	 */
	public boolean isAsync() {
		return isAsyncConverter(converter);
	}

	private boolean isAsyncConverter(IConverter converter) {
		if (converter != null) {
			return converter.isAsync();
		}
		return false;
	}
}

Lines 68-73 Link Here

(-)src/org/eclipse/core/databinding/UpdateStrategy.java (+19 lines)
68		68
69	private static Map converterMap;	69	private static Map converterMap;
70		70
		71	/**
		72	* Returns whether the update defined by this strategy is intended to be
		73	* executed asynchronously.
		74	*
		75	* <p>
		76	* By default, this method returns <code>false</code>.
		77	* </p>
		78	*
		79	* @return whether the update defined by this strategy is intended to be
		80	* executed asynchronously.
		81	*/
		82	public boolean isAsync() {
		83	return false;
		84	}
		85
71	private static Class autoboxed(Class clazz) {	86	private static Class autoboxed(Class clazz) {
72	if (clazz == Float.TYPE)	87	if (clazz == Float.TYPE)
73	return Float.class;	88	return Float.class;
Lines 705-710 Link Here
705	public Object getToType() {	720	public Object getToType() {
706	return toType;	721	return toType;
707	}	722	}
		723
		724	public boolean isAsync() {
		725	return false;
		726	}
708	}	727	}
709		728
710	}	729	}




 *     IBM Corporation - initial API and implementation
 *     Matt Carter - Character support completed (bug 197679)
 *     Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
 *     Ovidio Mallo - bug 233191
 *******************************************************************************/

package org.eclipse.core.databinding;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.IValidator2;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.internal.databinding.BindingMessages;
import org.eclipse.core.internal.databinding.Pair;

		return Status.OK_STATUS;
	}

	/**
	 * Returns whether the value update defined by this strategy is intended to
	 * be executed asynchronously.
	 * 
	 * <p>
	 * By default, this method returns <code>true</code> if and only if
	 * <i>any</i> of the validators or the converter associated to this strategy
	 * is intended to be executed asynchronously. Clients may extend without
	 * having to call the super implementation.
	 * </p>
	 * 
	 * <p>
	 * Note that even if this method returns <code>true</code>, there is no
	 * guarantee as of whether the value update will indeed by executed
	 * asynchronously or not.
	 * </p>
	 * 
	 * @return whether the value update defined by this strategy is intended to
	 *         be executed asynchronously.
	 * 
	 * @see IValidator2#isAsync()
	 * @see IConverter#isAsync()
	 */
	public boolean isAsync() {
		return isAsyncValidator(afterGetValidator)
				|| isAsyncConverter(converter)
				|| isAsyncValidator(afterConvertValidator)
				|| isAsyncValidator(beforeSetValidator);
	}

	private boolean isAsyncValidator(IValidator validator) {
		if (validator instanceof IValidator2) {
			return ((IValidator2) validator).isAsync();
		}
		return false;
	}

	private boolean isAsyncConverter(IConverter converter) {
		if (converter != null) {
			return converter.isAsync();
		}
		return false;
	}

	private static class ValidatorRegistry {

		private HashMap validators = new HashMap();




import java.util.Collections;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.internal.databinding.BindingStatus;
import org.eclipse.core.internal.databinding.UpdateExecutor;
import org.eclipse.core.internal.databinding.UpdateRunnable;
import org.eclipse.core.internal.databinding.UpdateValidationObservableValue;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;

/**
 * @since 1.0


	private UpdateListStrategy targetToModel;
	private UpdateListStrategy modelToTarget;
	private UpdateValidationObservableValue validationStatusObservable;
	private boolean updatingTarget;
	private boolean updatingModel;
	private UpdateExecutor updateExecutor;

	private IListChangeListener targetChangeListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {

	}

	protected void preInit() {
		updateExecutor = new UpdateExecutor(isAsync(), new Runnable() {
			public void run() {
				// If we are in asynchronous mode, we must update the staleness
				// of the validation observable upon every scheduling event.
				if (isAsync()) {
					validationStatusObservable.getRealm().exec(new Runnable() {
						public void run() {
							validationStatusObservable.updateStaleness();
						}
					});
				}
			}
		});

		validationStatusObservable = new UpdateValidationObservableValue(
				context.getValidationRealm()) {
			public boolean isStale() {
				ObservableTracker.getterCalled(this);
				// If not in asynchronous mode, we never set the validation
				// observable to be stale.
				return ListBinding.this.isAsync()
						&& updateExecutor.hasPendingUpdates();
			}
		};
	}

	protected void postInit() {

		// nothing for now
	}

	public boolean isAsync() {
		return targetToModel.isAsync() || modelToTarget.isAsync();
	}

	/*
	 * This method may be moved to UpdateListStrategy in the future if clients
	 * need more control over how the two lists are kept in sync.

			final UpdateListStrategy updateListStrategy,
			final boolean explicit, final boolean clearDestination) {
		final int policy = updateListStrategy.getUpdatePolicy();
		if (policy == UpdateListStrategy.POLICY_NEVER)
			return;
		if (policy == UpdateListStrategy.POLICY_ON_REQUEST && !explicit)
			return;

		UpdateRunnable update = new UpdateRunnable() {
			public void run() {
				final ListDiffEntry[] diffEntries = diff.getDifferences();
				for (int i = 0; i < diffEntries.length; i++) {
					ListDiffEntry entry = diffEntries[i];
					if (entry.isAddition()) {
						diffEntries[i] = Diffs.createListDiffEntry(entry
								.getPosition(), entry.isAddition(),
								updateListStrategy.convert(entry.getElement()));
					}
				}

				destination.getRealm().exec(new Runnable() {
					public void run() {
						// If the update has been canceled before writing to the
						// destination observable, we do not set the validation
						// status, so we return outside the below try block.
						if (isCanceled()) {
							notifyDone();
							return;
						}

						if (destination == getTarget()) {
							updatingTarget = true;
						} else {

							if (clearDestination) {
								destination.clear();
							}
							ListDiffEntry[] diffEntries = diff.getDifferences();
							for (int i = 0; i < diffEntries.length; i++) {
								ListDiffEntry listDiffEntry = diffEntries[i];
								if (listDiffEntry.isAddition()) {
									IStatus setterStatus = updateListStrategy
											.doAdd(destination, listDiffEntry
													.getElement(),
													updateListStrategy
															.convert(listDiffEntry
																	.getElement()),
													listDiffEntry.getPosition());

									mergeStatus(multiStatus, setterStatus);
									// TODO - at this point, the two lists
									// will be out of sync if an error
									// occurred...
								} else {
									IStatus setterStatus = updateListStrategy
											.doRemove(destination,
													listDiffEntry.getPosition());

									mergeStatus(multiStatus, setterStatus);
									// TODO - at this point, the two lists
									// will be out of sync if an error
									// occurred...
								}
							}
						} finally {

							} else {
								updatingModel = false;
							}

							notifyDone();
						}
					}
				});
			}
		};

		updateExecutor.execute(update, false);
	}

	/**

	}

	public void dispose() {
		updateExecutor.terminate();

		if (targetChangeListener != null) {
			((IObservableList)getTarget()).removeListChangeListener(targetChangeListener);
			targetChangeListener = null;




 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Matthew Hall - bug 220700
 *     Ovidio Mallo - bug 233191
 *******************************************************************************/

package org.eclipse.core.databinding;

import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.internal.databinding.BindingStatus;
import org.eclipse.core.internal.databinding.UpdateExecutor;
import org.eclipse.core.internal.databinding.UpdateRunnable;
import org.eclipse.core.internal.databinding.UpdateValidationObservableValue;
import org.eclipse.core.internal.databinding.Util;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;

class ValueBinding extends Binding {
	private final UpdateValueStrategy targetToModel;
	private final UpdateValueStrategy modelToTarget;
	private UpdateValidationObservableValue validationStatusObservable;
	private IObservableValue target;
	private IObservableValue model;
	private UpdateExecutor updateExecutor;

	private boolean updatingTarget;
	private boolean updatingModel;

	}

	protected void preInit() {
		updateExecutor = new UpdateExecutor(isAsync(), new Runnable() {
			public void run() {
				// If we are in asynchronous mode, we must update the staleness
				// of the validation observable upon every scheduling event.
				if (isAsync()) {
					validationStatusObservable.getRealm().exec(new Runnable() {
						public void run() {
							validationStatusObservable.updateStaleness();
						}
					});
				}
			}
		});

		validationStatusObservable = new UpdateValidationObservableValue(
				context.getValidationRealm()) {
			public boolean isStale() {
				ObservableTracker.getterCalled(this);
				// If not in asynchronous mode, we never set the validation
				// observable to be stale.
				return ValueBinding.this.isAsync()
						&& updateExecutor.hasPendingUpdates();
			}
		};
	}

	protected void postInit() {

	}

	/**
	 * Returns whether the updates performed by this binding are executed
	 * asynchronously.
	 * 
	 * <p>
	 * This method returns <code>true</code> if and only if <i>any</i> of the
	 * binding's update strategies is intended to be run asynchronously.
	 * Thereby, the individual updates of this binding are always guaranteed to
	 * be executed in the correct order, thus ensuring that the target and model
	 * values will never get out of sync due to the asynchronous nature of the
	 * updates.
	 * </p>
	 * 
	 * <p>
	 * In case the updates are executed asynchronously, the staleness state of
	 * the validation status observable can be used to determine whether there
	 * are any pending updates. This allows for awaiting the termination of
	 * those updates, if desired, by tracking the observable's staleness state.
	 * </p>
	 * 
	 * @return whether the updates performed by this binding are executed
	 *         asynchronously.
	 * 
	 * @see UpdateValueStrategy#isAsync()
	 */
	public boolean isAsync() {
		return targetToModel.isAsync() || modelToTarget.isAsync();
	}

	/**
	 * Incorporates the provided <code>newStats</code> into the
	 * <code>multieStatus</code>.
	 * 

			final IObservableValue destination,
			final UpdateValueStrategy updateValueStrategy,
			final boolean explicit, final boolean validateOnly) {

		final int policy = updateValueStrategy.getUpdatePolicy();
		if (policy == UpdateValueStrategy.POLICY_NEVER)
			return;


		source.getRealm().exec(new Runnable() {
			public void run() {
				// Get value
				final Object value = source.getValue();

				UpdateRunnable update = new UpdateRunnable() {
					public void run() {
						boolean destinationRealmReached = false;
						final MultiStatus multiStatus = BindingStatus.ok();
						try {
							// Validate after get
							IStatus status = updateValueStrategy
									.validateAfterGet(value);
							if (!mergeStatus(multiStatus, status))
								return;

							// Convert value
							final Object convertedValue = updateValueStrategy
									.convert(value);

							// Validate after convert
							status = updateValueStrategy
									.validateAfterConvert(convertedValue);
							if (!mergeStatus(multiStatus, status))
								return;
							if (policy == UpdateValueStrategy.POLICY_CONVERT
									&& !explicit)
								return;

							// Validate before set
							status = updateValueStrategy
									.validateBeforeSet(convertedValue);
							if (!mergeStatus(multiStatus, status))
								return;
							if (validateOnly)
								return;

							// Set value
							destinationRealmReached = true;
							destination.getRealm().exec(new Runnable() {
								public void run() {
									// If the update has been canceled before
									// writing to the destination observable, we
									// do not set the validation status, so we
									// return outside the below try block.
									if (isCanceled()) {
										notifyDone();
										return;
									}

									if (destination == target) {
										updatingTarget = true;
									} else {
										updatingModel = true;
									}
									try {
										IStatus setterStatus = updateValueStrategy
												.doSet(destination,
														convertedValue);

										mergeStatus(multiStatus, setterStatus);
									} finally {
										if (destination == target) {
											updatingTarget = false;
										} else {
											updatingModel = false;
										}
										setValidationStatus(multiStatus);
										notifyDone();
									}
								}
							});
						} catch (Exception ex) {
							// This check is necessary as in 3.2.2 Status
							// doesn't accept a null message (bug 177264).
							String message = (ex.getMessage() != null) ? ex
									.getMessage() : ""; //$NON-NLS-1$

							mergeStatus(multiStatus, new Status(IStatus.ERROR,
									Policy.JFACE_DATABINDING, IStatus.ERROR,
									message, ex));
						} finally {
							if (!destinationRealmReached) {
								// Set the validation status unless the update
								// has been canceled in the meanwhile.
								if (!isCanceled()) {
									setValidationStatus(multiStatus);
								}
								notifyDone();
							}
						}
					});
				} catch (Exception ex) {
					// This check is necessary as in 3.2.2 Status
					// doesn't accept a null message (bug 177264).
					String message = (ex.getMessage() != null) ? ex
							.getMessage() : ""; //$NON-NLS-1$

					mergeStatus(multiStatus, new Status(IStatus.ERROR,
							Policy.JFACE_DATABINDING, IStatus.ERROR, message,
							ex));
				} finally {
					if (!destinationRealmReached) {
						setValidationStatus(multiStatus);
					}
				};

				updateExecutor.execute(update, !explicit);
			}
		});
	}

	}
	
	public void dispose() {
		updateExecutor.terminate();

		if (targetChangeListener != null) {
			target.removeValueChangeListener(targetChangeListener);
			targetChangeListener = null;

Lines 53-56 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/ObjectToStringConverter.java (+3 lines)
53	return String.class;	53	return String.class;
54	}	54	}
55		55
		56	public boolean isAsync() {
		57	return false;
		58	}
56	}	59	}

Lines 85-88 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/StringToBooleanPrimitiveConverter.java (+3 lines)
85	return Boolean.TYPE;	85	return Boolean.TYPE;
86	}	86	}
87		87
		88	public boolean isAsync() {
		89	return false;
		90	}
88	}	91	}

Lines 32-36 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/StringToDateConverter.java (-1 / +5 lines)
32		32
33	public Object getToType() {	33	public Object getToType() {
34	return Date.class;	34	return Date.class;
35	}	35	}
		36
		37	public boolean isAsync() {
		38	return false;
		39	}
36	}	40	}

Lines 35-39 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/DateToStringConverter.java (-1 / +5 lines)
35		35
36	public Object getToType() {	36	public Object getToType() {
37	return String.class;	37	return String.class;
38	}	38	}
		39
		40	public boolean isAsync() {
		41	return false;
		42	}
39	}	43	}

Lines 107-110 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/IdentityConverter.java (+3 lines)
107	return toType;	107	return toType;
108	}	108	}
109		109
		110	public boolean isAsync() {
		111	return false;
		112	}
110	}	113	}

Lines 70-75 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/StringToCharacterConverter.java (+4 lines)
70	return primitiveTarget ? Character.TYPE : Character.class;	70	return primitiveTarget ? Character.TYPE : Character.class;
71	}	71	}
72		72
		73	public boolean isAsync() {
		74	return false;
		75	}
		76
73	/**	77	/**
74	* @param primitive	78	* @param primitive
75	* @return converter	79	* @return converter

Lines 72-75 Link Here

(-)src/org/eclipse/core/internal/databinding/Queue.java (+8 lines)
72	public boolean isEmpty() {	72	public boolean isEmpty() {
73	return first == null;	73	return first == null;
74	}	74	}
		75
		76	/**
		77	* Removes all elements from this queue.
		78	*/
		79	public void clear() {
		80	first = null;
		81	last = null;
		82	}
75	}	83	}

Lines 22-28 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
22	org.eclipse.core.internal.databinding.observable.masterdetail;x-friends:="org.eclipse.jface.tests.databinding",	22	org.eclipse.core.internal.databinding.observable.masterdetail;x-friends:="org.eclipse.jface.tests.databinding",
23	org.eclipse.core.internal.databinding.observable.tree;x-friends:="org.eclipse.jface.databinding,org.eclipse.jface.tests.databinding",	23	org.eclipse.core.internal.databinding.observable.tree;x-friends:="org.eclipse.jface.databinding,org.eclipse.jface.tests.databinding",
24	org.eclipse.core.internal.databinding.validation;x-friends:="org.eclipse.jface.tests.databinding"	24	org.eclipse.core.internal.databinding.validation;x-friends:="org.eclipse.jface.tests.databinding"
25	Require-Bundle: org.eclipse.equinox.common;bundle-version="[3.2.0,4.0.0)"	25	Require-Bundle: org.eclipse.equinox.common;bundle-version="[3.2.0,4.0.0)",
		26	org.eclipse.core.jobs
26	Import-Package-Comment: see http://wiki.eclipse.org/	27	Import-Package-Comment: see http://wiki.eclipse.org/
27	Import-Package: com.ibm.icu.text,	28	Import-Package: com.ibm.icu.text,
28	org.osgi.framework;version="[1.4.0,2.0.0)";resolution:=optional,	29	org.osgi.framework;version="[1.4.0,2.0.0)";resolution:=optional,

Lines 40-43 Link Here

(-)src/org/eclipse/core/databinding/conversion/Converter.java (+6 lines)
40	return toType;	40	return toType;
41	}	41	}
42		42
		43	/**
		44	* By default, this method returns <code>false</code>.
		45	*/
		46	public boolean isAsync() {
		47	return false;
		48	}
43	}	49	}




	 * @return the converted object, of type {@link #getToType()}
	 */
	public Object convert(Object fromObject);

	/**
	 * Returns whether the {@link #convert(Object)} method of this converter is
	 * intended to be executed asynchronously.
	 * 
	 * <p>
	 * Note that even if this method returns <code>true</code>, there is no
	 * guarantee as of whether the conversion will indeed by executed
	 * asynchronously or not.
	 * </p>
	 * 
	 * @return whether the {@link #convert(Object)} method of this converter is
	 *         intended to be executed asynchronously.
	 */
	public boolean isAsync();
}




 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 218269)
 *     Boris Bokowski - bug 218269
 *     Ovidio Mallo - bug 233191
 ******************************************************************************/

package org.eclipse.core.databinding.validation;


import org.eclipse.core.databinding.ValidationStatusProvider;
import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.ObservableTracker;

import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.internal.databinding.observable.ValidatedObservableList;
import org.eclipse.core.internal.databinding.observable.ValidatedObservableMap;

 */
public abstract class MultiValidator extends ValidationStatusProvider {
	private Realm realm;
	private ValidationStatusObservableValue validationStatus;
	private IObservableValue unmodifiableValidationStatus;
	private WritableList targets;
	private IObservableList unmodifiableTargets;
	private IObservableList models;
	private boolean stale = false;

	IListChangeListener targetsListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {

		Assert.isNotNull(realm, "Realm cannot be null"); //$NON-NLS-1$
		this.realm = realm;

		validationStatus = new ValidationStatusObservableValue(realm);
				IStatus.class);

		targets = new WritableList(realm, new ArrayList(), IObservable.class);
		targets.addListChangeListener(targetsListener);

	 * validation status of this MultiValidator. The returned observable is in
	 * the same realm as this MultiValidator.
	 * 
	 * <p>
	 * In case the validation of this MultiValidator is performed
	 * asynchronously, the staleness state of the validation status observable
	 * can be used to determine whether there are any pending validations. This
	 * allows for awaiting the termination of those validations, if desired, by
	 * tracking the observable's staleness state.
	 * 
	 * @return an {@link IObservableValue} whose value is always the current
	 *         validation status of this MultiValidator.
	 */

	protected abstract IStatus validate();

	/**
	 * Notifies the MultiValidator that the current validation status is being
	 * computed asynchronously and is not available yet.
	 * 
	 * <p>
	 * Subclasses should invoke this method whenever the {@link #validate()
	 * validation} is performed asynchronously. Calling this method guarantees
	 * that the {@link #getValidationStatus() validation status observable} is
	 * correctly set to be stale.
	 * 
	 * <p>
	 * Typically, this method should be called from within the
	 * {@link #validate()} method when the asynchronous validation is started
	 * while a reasonable validation status must always be returned to be used
	 * while the pending validation has not terminated. Once the validation is
	 * available, it can be passed to the MultiValidator by calling the
	 * {@link #exitStale(IStatus)} method.
	 * 
	 * <p>
	 * Note: This method must be called from within the MultiValidator's realm.
	 * 
	 * @see #exitStale(IStatus)
	 * @see IObservableValue#isStale()
	 */
	protected final void enterStale() {
		stale = true;
		validationStatus.fireStale();
	}

	/**
	 * Notifies the MultiValidator that an asynchronous validation has
	 * terminated which resulted in the given validation status.
	 * 
	 * <p>
	 * This method sets the given <code>status</code> as the current validation
	 * status and sets the {@link #getValidationStatus() validation status
	 * observable} to not be stale anymore.
	 * 
	 * <p>
	 * Note: This method must be called from within the MultiValidator's realm.
	 * 
	 * @param status
	 *            the resulting status of the terminated validation.
	 * 
	 * @see #enterStale()
	 * @see IObservableValue#isStale()
	 */
	protected final void exitStale(IStatus status) {
		stale = false;
		Object oldStatus = validationStatus.getValue();
		validationStatus.setValue(status);

		// In order to signal that the validation status observable is not stale
		// anymore, we must always fire a value change event, even if the
		// validation status has not changed. In the latter case, we must do so
		// explicitly.
		if (oldStatus.equals(status)) {
			validationStatus.fireValueChange(Diffs.createValueDiff(oldStatus,
					status));
		}
	}

	/**
	 * Returns a wrapper {@link IObservableValue} which stays in sync with the
	 * given target observable only when the validation status is valid.
	 * Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or

		super.dispose();
	}

	private class ValidationStatusObservableValue extends WritableValue {

		public ValidationStatusObservableValue(Realm realm) {
			super(realm, ValidationStatus.ok(), IStatus.class);
		}

		public boolean isStale() {
			ObservableTracker.getterCalled(this);
			return stale;
		}

		protected void fireStale() {
			// Make the method accessible to the MultiValidator class.
			super.fireStale();
		}

		protected void fireValueChange(ValueDiff diff) {
			// Make the method accessible to the MultiValidator class.
			super.fireValueChange(diff);
		}
	}
}

Lines 55-58 Link Here

(-)src/org/eclipse/core/internal/databinding/observable/UnmodifiableObservableValue.java (+4 lines)
55	public Object getValueType() {	55	public Object getValueType() {
56	return wrappedValue.getValueType();	56	return wrappedValue.getValueType();
57	}	57	}
		58
		59	public boolean isStale() {
		60	return wrappedValue.isStale();
		61	}
58	}	62	}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.core.internal.databinding;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;

/**
 * Simple class to manage the execution of {@link UpdateRunnable}s intended to
 * be used for performing the updates of a binding.
 * 
 * <p>
 * This class is thread safe and supports the synchronous as well as
 * asynchronous execution of a set of UpdateRunnables where consecutive updates
 * are guaranteed to be executed in the correct order. In addition, this class
 * allows for tracking the set of pending updates which can eventually be
 * canceled upon scheduling a new update which makes previous updates obsolete.
 * </p>
 * 
 * @see #execute(UpdateRunnable, boolean)
 * @see #hasPendingUpdates()
 */
public class UpdateExecutor {

	private final boolean isAsync;

	private final Runnable schedulingEventCallback;

	private final Set pendingUpdates = new HashSet();

	private final UpdateJob updateJob;

	/**
	 * Creates a new UpdateExecutor which will run the individual updates either
	 * synchronously or asynchronously.
	 * 
	 * @param isAsync
	 *            whether the UpdateRunnables passed to this UpdateExecutor
	 *            should be executed asynchronously.
	 * @param schedulingEventCallback
	 *            a callback Runnable which will be executed whenever some
	 *            scheduling event in the execution of the updates happened. The
	 *            code in the runnable can then use this classes API to retrieve
	 *            the relevant information. May be <code>null</code>.
	 */
	public UpdateExecutor(boolean isAsync, Runnable schedulingEventCallback) {
		this.isAsync = isAsync;
		this.schedulingEventCallback = schedulingEventCallback;

		// Only instantiate the UpdateJob if we are in asynchronous mode.
		if (isAsync) {
			this.updateJob = new UpdateJob();
			this.updateJob.setSystem(true);
		} else {
			this.updateJob = null;
		}
	}

	/**
	 * Executes the given {@link UpdateRunnable update} and eventually tries to
	 * cancel previous, still pending updates, if desired.
	 * 
	 * @param update
	 *            the new update to execute.
	 * @param cancelPendingUpdates
	 *            whether previous, still pending updates, should be requested
	 *            to be {@link UpdateRunnable#cancel() canceled} before
	 *            executing the new update.
	 * 
	 * @see UpdateRunnable#run()
	 * @see UpdateRunnable#cancel()
	 */
	public void execute(UpdateRunnable update, boolean cancelPendingUpdates) {
		// If requested, we try to cancel previous updates.
		if (cancelPendingUpdates) {
			cancelPendingUpdates();
		}

		// The executor must be set on the UpdateRunnable in order to get
		// notified of the update's termination.
		update.setExecutor(this);

		// Add the new update to the set of pending updates.
		synchronized (pendingUpdates) {
			pendingUpdates.add(update);
		}

		// Right before starting the update, we notify about the new update.
		if (schedulingEventCallback != null) {
			schedulingEventCallback.run();
		}

		if (isAsync) {
			synchronized (updateJob.updateQueue) {
				// Whenever we are adding a new update to an empty queue, we
				// must re-schedule the UpdateJob. Note that it is OK to do this
				// before actually adding the update to the queue since we are
				// already holding the lock on the queue at this point.
				if (updateJob.updateQueue.isEmpty()) {
					updateJob.schedule();
				}
				updateJob.updateQueue.enqueue(update);
			}
		} else {
			// In synchronous mode, we simply execute the run method.
			update.run();
		}
	}

	/**
	 * Indicates that the given update was running and has now terminated.
	 * 
	 * @param update
	 *            the update which has terminated.
	 * 
	 * @see #hasPendingUpdates()
	 * @see UpdateRunnable#notifyDone()
	 */
	/* package */void endUpdate(UpdateRunnable update) {
		synchronized (pendingUpdates) {
			pendingUpdates.remove(update);
		}

		if (schedulingEventCallback != null) {
			schedulingEventCallback.run();
		}
	}

	/**
	 * Returns whether there are any pending updates to be executed on behalf of
	 * this UpdateExecutor.
	 * 
	 * <p>
	 * Note that an update is defined to be pending as soon as it has been
	 * passed to this UpdateExecutor for
	 * {@link #execute(UpdateRunnable, boolean) execution}, regardless of
	 * whether the update is already running or not.
	 * </p>
	 * 
	 * @return whether there are any pending updates to be executed on behalf of
	 *         this UpdateExecutor.
	 */
	public boolean hasPendingUpdates() {
		synchronized (pendingUpdates) {
			return !pendingUpdates.isEmpty();
		}
	}

	/**
	 * Requests all the pending updates to be canceled.
	 * 
	 * <p>
	 * This method guarantees that by the end of its execution, all the pending
	 * updates have been requested to be {@link UpdateRunnable#cancel()
	 * canceled} and that updates which have not been started yet (if in
	 * asynchronous mode) will never be run.
	 * </p>
	 * 
	 * @see UpdateRunnable#cancel()
	 */
	private void cancelPendingUpdates() {
		synchronized (pendingUpdates) {
			// Cancel all the pending updates.
			for (Iterator iter = pendingUpdates.iterator(); iter.hasNext();) {
				UpdateRunnable update = (UpdateRunnable) iter.next();
				update.cancel();
			}
			pendingUpdates.clear();
		}

		if (isAsync) {
			// If in asynchronous mode, we must also clear the queue of updates
			// waiting to be run.
			synchronized (updateJob.updateQueue) {
				updateJob.updateQueue.clear();
			}
		}
	}

	/**
	 * Terminates the UpdateExecutor by canceling any eventual pending update.
	 * 
	 * <p>
	 * Note that once this method has been called, no further updates should be
	 * run on behalf of this UpdateExecutor.
	 * </p>
	 */
	public void terminate() {
		cancelPendingUpdates();

		if (schedulingEventCallback != null) {
			schedulingEventCallback.run();
		}
	}

	private class UpdateJob extends Job {

		private final Queue updateQueue = new Queue();

		public UpdateJob() {
			super("Update Job"); //$NON-NLS-1$
		}

		protected IStatus run(IProgressMonitor monitor) {
			while (true) {
				UpdateRunnable update;
				synchronized (updateQueue) {
					// As soon as we get out of work, we return in order to
					// release the Thread on whose behalf the job is running.
					if (updateQueue.isEmpty()) {
						return Status.OK_STATUS;
					}
					update = (UpdateRunnable) updateQueue.dequeue();
				}
				update.run();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.core.databinding.validation;

/**
 * Extension of the {@link IValidator} interface which adds API for expressing
 * the intend of a validator to be executed asynchronously.
 */
public interface IValidator2 extends IValidator {

	/**
	 * Returns whether the {@link #validate(Object)} method of this validator is
	 * intended to be executed asynchronously.
	 * 
	 * <p>
	 * Note that even if this method returns <code>true</code>, there is no
	 * guarantee as of whether the validation will indeed by executed
	 * asynchronously or not.
	 * </p>
	 * 
	 * @return whether the {@link #validate(Object)} method of this validator is
	 *         intended to be executed asynchronously.
	 */
	public boolean isAsync();
}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.core.internal.databinding;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

/**
 * Simple {@link IObservableValue} of type {@link IStatus} intended to be used
 * for the validation resulting from the update process of a binding.
 * 
 * <p>
 * This observable provides some convenience API to signal a possible change in
 * its staleness state. Whenever the staleness of the validation observable
 * changes (or may have changed), {@link #updateStaleness()} should be called
 * which either fires a stale event in case the method {@link #isStale()}
 * returns <code>true</code>, or else, a value change event is fired in order to
 * signal that the observable is not stale anymore. Subclasses must implement
 * the {@link #isStale()} method.
 * </p>
 */
public abstract class UpdateValidationObservableValue extends
		AbstractObservableValue {

	private Object value = Status.OK_STATUS;

	/**
	 * Creates a new observable with the initial value
	 * <code>Status.OK_STATUS</code> in the given realm.
	 * 
	 * @param realm
	 *            the observable's realm.
	 */
	public UpdateValidationObservableValue(Realm realm) {
		super(realm);
	}

	protected Object doGetValue() {
		return value;
	}

	protected void doSetValue(Object value) {
		Object oldValue = this.value;
		this.value = value;
		if (!Util.equals(oldValue, value)) {
			fireValueChange(Diffs.createValueDiff(oldValue, value));
		}
	}

	/**
	 * Updates the staleness of this validation by either firing a stale event
	 * in case the method {@link #isStale()} returns <code>true</code>, or else,
	 * by firing a value change event in order to signal that the observable is
	 * not stale anymore.
	 */
	public void updateStaleness() {
		if (isStale()) {
			fireStale();
		} else {
			// This synthetic value change event is merely used to signal that
			// the observable is not stale anymore.
			fireValueChange(Diffs.createValueDiff(getValue(), getValue()));
		}
	}

	public abstract boolean isStale();

	public Object getValueType() {
		return IStatus.class;
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.core.internal.databinding;

/**
 * Simple implementation of a <code>Runnable</code> which can be used to have a
 * binding update executed by an {@link UpdateExecutor}.
 * 
 * <p>
 * This thread safe class adds methods to support a collaborative
 * {@link #cancel() canceling} of a running update. In addition, in order to
 * allow for an <code>UpdateExecutor</code> to keep track of the updates
 * currently running on its behalf, every <code>UpdateRunnable</code> is
 * responsible for {@link #notifyDone() notifying} the executor about its
 * completion.
 * </p>
 * 
 * @see #cancel()
 * @see #notifyDone()
 */
public abstract class UpdateRunnable implements Runnable {

	private UpdateExecutor executor;

	private volatile boolean canceled = false;

	/**
	 * Sets the {@link UpdateExecutor} on whose behalf this update is executed.
	 * 
	 * @param executor
	 *            the <code>UpdateExecutor</code> on whose behalf this update is
	 *            executed.
	 */
	/* package */final synchronized void setExecutor(UpdateExecutor executor) {
		this.executor = executor;
	}

	/**
	 * Signals that this update has completed.
	 * 
	 * <p>
	 * Calling this method is typically the responsibility of the running update
	 * itself and is used to allow for the {@link UpdateExecutor executor} of
	 * this update to keep track of the pending updates.
	 * </p>
	 * 
	 * <p>
	 * Note that if an update terminates asynchronously, this method should only
	 * be called as soon as the update really terminates and not already when
	 * reaching the end of the {@link #run()} method.
	 * </p>
	 * 
	 * @see #setExecutor(UpdateExecutor)
	 * @see UpdateExecutor#endUpdate(UpdateRunnable)
	 */
	protected final synchronized void notifyDone() {
		if (executor != null) {
			executor.endUpdate(this);
		}
	}

	/**
	 * Returns whether this update has been requested to be canceled.
	 * 
	 * @return whether this update has been requested to be canceled.
	 * 
	 * @see #cancel()
	 */
	public final boolean isCanceled() {
		return canceled;
	}

	/**
	 * Requests this update to be canceled while it is up to the running update
	 * to decide if and when the update can be canceled before its natural
	 * completion.
	 * 
	 * @see #isCanceled()
	 */
	public final void cancel() {
		this.canceled = true;
	}
}

Lines 252-257 Link Here

(-)src/org/eclipse/jface/examples/databinding/nestedselection/TestMasterDetail.java (+4 lines)
252	public Object getToType() {	252	public Object getToType() {
253	return String.class;	253	return String.class;
254	}	254	}
		255
		256	public boolean isAsync() {
		257	return false;
		258	}
255	};	259	};
256	IValidator vowelValidator = new IValidator() {	260	IValidator vowelValidator = new IValidator() {
257	public IStatus validate(Object value) {	261	public IStatus validate(Object value) {




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.jface.examples.databinding.snippets;

import java.util.Random;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateListStrategy;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.conversion.Converter;
import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Spinner;
import org.eclipse.swt.widgets.Text;

/**
 * Snippet that demonstrates the usage of asynchronous bindings by defining an
 * asynchronous converter which introduces some artificial delay during
 * conversion. The example allows to manually change the target or model of a
 * ValueBinding/ListBinding and to see how the counterpart gets updated
 * asynchronously. In addition, automatic updates of the target and/or model can
 * be triggered.
 */
public class Snippet022AsyncUpdate {

	private int updateDelay = 1000;

	private boolean randomizeUpdateDelay = true;

	private DataBindingContext dbc;

	private WritableValue valueTarget;

	private WritableValue valueModel;

	private WritableList listTarget;

	private WritableList listModel;

	public void createControl(Composite parent) {
		dbc = new DataBindingContext();

		parent.setLayout(GridLayoutFactory.fillDefaults().margins(5, 5)
				.spacing(15, 10).create());

		createSettingsGroup(parent);
		createValueBindingGroup(parent);
		createListBindingGroup(parent);
		createAutomaticUpdatesGroup(parent);
	}

	private void createSettingsGroup(Composite parent) {
		Group group = new Group(parent, SWT.NONE);
		group.setText("Settings");
		group.setLayout(GridLayoutFactory.fillDefaults().numColumns(2).margins(
				5, 7).spacing(15, 10).create());
		GridDataFactory.fillDefaults().grab(true, false).applyTo(group);

		new Label(group, SWT.NONE).setText("Update delay");
		final Spinner updateDelaySpinner = new Spinner(group, SWT.BORDER);
		GridDataFactory.fillDefaults().grab(true, false).applyTo(
				updateDelaySpinner);
		updateDelaySpinner.setMinimum(1);
		updateDelaySpinner.setMaximum(Integer.MAX_VALUE);
		updateDelaySpinner.setSelection(updateDelay);
		updateDelaySpinner.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				updateDelay = updateDelaySpinner.getSelection();
			}
		});

		final Button randomizeUpdateDelayButton = new Button(group, SWT.CHECK);
		randomizeUpdateDelayButton.setText("Randomize update delay");
		GridDataFactory.fillDefaults().grab(true, false).span(2, 1).applyTo(
				randomizeUpdateDelayButton);
		randomizeUpdateDelayButton.setSelection(randomizeUpdateDelay);
		randomizeUpdateDelayButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				randomizeUpdateDelay = randomizeUpdateDelayButton
						.getSelection();
			}
		});
	}

	private void createValueBindingGroup(Composite parent) {
		Group group = new Group(parent, SWT.NONE);
		group.setText("Value Binding");
		group.setLayout(GridLayoutFactory.fillDefaults().numColumns(2).margins(
				5, 7).spacing(15, 10).create());
		GridDataFactory.fillDefaults().grab(true, false).applyTo(group);

		valueTarget = WritableValue.withValueType(String.class);
		createValueComponent(group, "Target", valueTarget);

		valueModel = WritableValue.withValueType(String.class);
		createValueComponent(group, "Model", valueModel);

		dbc.bindValue(valueTarget, valueModel, new UpdateValueStrategy()
				.setConverter(asyncConverter()), new UpdateValueStrategy()
				.setConverter(asyncConverter()));
	}

	private void createValueComponent(Composite parent, String title,
			IObservableValue observableValue) {
		new Label(parent, SWT.NONE).setText(title);
		Text text = new Text(parent, SWT.BORDER);
		GridDataFactory.fillDefaults().grab(true, false).applyTo(text);

		dbc.bindValue(SWTObservables.observeText(text, SWT.Modify),
				observableValue, null, null);
	}

	private void createListBindingGroup(Composite parent) {
		Group group = new Group(parent, SWT.NONE);
		group.setText("List Binding");
		group.setLayout(GridLayoutFactory.fillDefaults().numColumns(2).margins(
				5, 7).spacing(15, 10).create());
		GridDataFactory.fillDefaults().grab(true, true).applyTo(group);

		listTarget = WritableList.withElementType(String.class);
		createListComponent(group, "Target", listTarget);

		listModel = WritableList.withElementType(String.class);
		createListComponent(group, "Model", listModel);

		dbc.bindList(listTarget, listModel, new UpdateListStrategy()
				.setConverter(asyncConverter()), new UpdateListStrategy()
				.setConverter(asyncConverter()));
	}

	private void createListComponent(Composite parent, String title,
			final IObservableList observableList) {
		new Label(parent, SWT.NONE).setText(title);
		final Text targetText = new Text(parent, SWT.BORDER);
		GridDataFactory.fillDefaults().grab(true, false).applyTo(targetText);
		targetText.addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.keyCode == SWT.CR) {
					observableList.add(targetText.getText());
					targetText.selectAll();
				}
			}
		});
		new Label(parent, SWT.NONE);
		final ListViewer targetList = new ListViewer(parent, SWT.BORDER
				| SWT.MULTI | SWT.V_SCROLL);
		GridDataFactory.fillDefaults().minSize(SWT.DEFAULT, 150).grab(true,
				true).applyTo(targetList.getList());
		targetList.setContentProvider(new ObservableListContentProvider());
		targetList.setLabelProvider(new LabelProvider());
		targetList.setInput(observableList);
		targetList.getList().addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.keyCode == SWT.DEL) {
					IStructuredSelection selection = (IStructuredSelection) targetList
							.getSelection();
					observableList.removeAll(selection.toList());
				}
			}
		});
	}

	private void createAutomaticUpdatesGroup(Composite parent) {
		Group group = new Group(parent, SWT.NONE);
		group.setText("Automatic Updates");
		group.setLayout(GridLayoutFactory.fillDefaults().numColumns(3)
				.equalWidth(true).margins(5, 5).create());
		GridDataFactory.fillDefaults().grab(true, false).applyTo(group);

		Button targetButton = new Button(group, SWT.PUSH);
		targetButton.setText("Target");
		GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true,
				false).applyTo(targetButton);
		targetButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				valueModel.setValue("");
				listTarget.clear();
				for (int i = 0; i < 10; i++) {
					String value = String.valueOf(i);
					valueTarget.setValue(value);
					listTarget.add(value);

					Display.getCurrent().update();
					sleep(100);
				}
			}
		});

		Button modelButton = new Button(group, SWT.PUSH);
		modelButton.setText("Model");
		GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true,
				false).applyTo(modelButton);
		modelButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				valueTarget.setValue("");
				listModel.clear();
				for (int i = 0; i < 10; i++) {
					String value = String.valueOf(i);
					valueModel.setValue(value);
					listModel.add(value);

					Display.getCurrent().update();
					sleep(100);
				}
			}
		});

		Button twowayButton = new Button(group, SWT.PUSH);
		twowayButton.setText("Twoway");
		GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true,
				false).applyTo(twowayButton);
		twowayButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				valueTarget.setValue("");
				valueModel.setValue("");
				listTarget.clear();
				listModel.clear();
				for (int i = 0; i < 10; i++) {
					String value = String.valueOf(i);
					if (i % 2 == 0) {
						valueTarget.setValue(value);
						listTarget.add(value);
					} else {
						valueModel.setValue(value);
						listModel.add(value);
					}

					Display.getCurrent().update();
					sleep(100);
				}
			}
		});
	}

	private IConverter asyncConverter() {
		return new Converter(null, null) {
			private final Random random = new Random(System.currentTimeMillis());

			public Object convert(Object fromObject) {
				if (randomizeUpdateDelay) {
					sleep(random.nextInt(updateDelay));
				} else {
					sleep(updateDelay);
				}

				return fromObject;
			}

			public boolean isAsync() {
				return true;
			}
		};
	}

	private static void sleep(long millis) {
		try {
			Thread.sleep(millis);
		} catch (InterruptedException e1) {
			// go ahead
		}
	}

	public static void main(String[] args) {
		Display display = new Display();

		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
			public void run() {
				Display display = Display.getCurrent();
				final Shell shell = new Shell(display);
				shell.setText("Asynchronous Bindings");
				new Snippet022AsyncUpdate().createControl(shell);

				shell.setMinimumSize(shell.computeSize(350, SWT.DEFAULT));
				shell.pack();
				shell.open();

				// The SWT event loop
				while (!shell.isDisposed()) {
					if (!display.readAndDispatch()) {
						display.sleep();
					}
				}
				display.dispose();
			}
		});
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation (bug 233191)
 ******************************************************************************/

package org.eclipse.jface.examples.databinding.snippets;

import java.util.Random;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.databinding.validation.IValidator2;
import org.eclipse.core.databinding.validation.MultiValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.wizard.WizardPageSupport;
import org.eclipse.jface.examples.databinding.decoration.ControlDecorator;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

/**
 * Snippet that demonstrates the usage of asynchronous binding as well as cross
 * field validations in the context of a wizard page. The example mainly tries
 * to illustrate how the WizardPageSupport class tracks the staleness state of
 * all the ValidationStatusProviders of the given data binding context, thus
 * waiting for pending validations before allowing the user to flip to the next
 * wizard page.
 */
public class Snippet023AsyncUpdateWizard {

	private static class AsyncBindingWizardPage extends WizardPage {

		public AsyncBindingWizardPage() {
			super("Asynchronous Bindings", "Asynchronous Bindings",
					ImageDescriptor.createFromImage(new Image(Display
							.getCurrent(), 16, 16)));
		}

		public void createControl(Composite parent) {
			Composite container = new Composite(parent, SWT.NONE);
			container.setLayout(GridLayoutFactory.fillDefaults().numColumns(2)
					.margins(5, 5).spacing(15, 10).create());
			GridDataFactory.fillDefaults().grab(true, false).applyTo(container);

			final DataBindingContext dbc = new DataBindingContext();

			// We use a control decorator to better illustrate when validations
			// are pending on the individual bindings.
			ControlDecorator controlDecorator = new ControlDecorator();
			controlDecorator.addDbc(dbc);

			WizardPageSupport.create(this, dbc);

			new Label(container, SWT.NONE).setText("Value 1");
			Text v1Text = new Text(container, SWT.BORDER);
			GridDataFactory.fillDefaults().grab(true, false).applyTo(v1Text);

			final WritableValue value1 = new WritableValue();
			dbc.bindValue(SWTObservables.observeText(v1Text, SWT.Modify),
					value1, asyncStrategy(), null);

			new Label(container, SWT.NONE).setText("Value 2");
			Text v2Text = new Text(container, SWT.BORDER);
			GridDataFactory.fillDefaults().grab(true, false).applyTo(v2Text);

			final WritableValue value2 = new WritableValue();
			dbc.bindValue(SWTObservables.observeText(v2Text, SWT.Modify),
					value2, asyncStrategy(), null);

			// Define the cross field validator.
			MultiValidator multiValidator = new MultiValidator() {
				private Job validationJob;

				protected IStatus validate() {
					// Cancel any previous job when re-evaluating the
					// validation.
					if (validationJob != null) {
						validationJob.cancel();
					}

					// The observables cannot be accessed from within a
					// different thread so we must extract their containing
					// values at this point.
					final Object v1 = value1.getValue();
					final Object v2 = value2.getValue();
					validationJob = new Job("Equality validation") {
						protected IStatus run(final IProgressMonitor monitor) {
							// Do the actual validation.
							final IStatus validation;
							if (!Util.equals(v1, v2)) {
								validation = ValidationStatus
										.error("The two values must be equal.");
							} else {
								validation = ValidationStatus.ok();
							}

							// Take it easy :-).
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								// go ahead
							}

							// Notify the MultiValidator about the completed
							// validation. This must be done from within the
							// MultiValidator's realm (here the validation
							// realm).
							dbc.getValidationRealm().exec(new Runnable() {
								public void run() {
									// Check if this validation has been
									// canceled in the meanwhile.
									if (!monitor.isCanceled()) {
										exitStale(validation);
									}
								}
							});

							return Status.OK_STATUS;
						}
					};
					validationJob.setSystem(true);
					validationJob.schedule();

					// Notify the MultiValidator about the validation being
					// performed asynchronously.
					enterStale();

					// Return a temporary validation to be shown to the user
					// while the actual validation has not completed.
					return ValidationStatus
							.info("Cross field validation is pending...");
				}

				public void dispose() {
					if (validationJob != null) {
						validationJob.cancel();
					}

					super.dispose();
				}
			};
			dbc.addValidationStatusProvider(multiValidator);

			setControl(container);
		}
	}

	private static UpdateValueStrategy asyncStrategy() {
		IValidator2 asyncValidator = new IValidator2() {
			private final Random random = new Random(System.currentTimeMillis());

			public IStatus validate(Object value) {
				try {
					Thread.sleep(random.nextInt(1000));
				} catch (InterruptedException e) {
					// go ahead
				}

				String input = (String) value;
				if (input != null) {
					if (input.length() > 15) {
						return ValidationStatus.error("Input is too long.");
					}
				}

				return ValidationStatus.ok();
			}

			public boolean isAsync() {
				return true;
			}
		};

		return new UpdateValueStrategy().setBeforeSetValidator(asyncValidator);
	}

	public static void main(String[] args) {
		Display display = new Display();

		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
			public void run() {
				Display display = Display.getCurrent();
				final Shell shell = new Shell(display);
				shell.setText("Asynchronous Bindings");

				Wizard wizard = new Wizard() {
					public boolean performFinish() {
						return true;
					}
				};
				wizard.setWindowTitle("Asynchronous Bindings");
				wizard.addPage(new AsyncBindingWizardPage());

				WizardDialog dialog = new WizardDialog(shell, wizard);
				dialog.open();

				display.dispose();
			}
		});
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Ovidio Mallo and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Ovidio Mallo - initial API and implementation
 ******************************************************************************/

package org.eclipse.jface.examples.databinding.decoration;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;
import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.databinding.swt.ISWTObservable;
import org.eclipse.jface.fieldassist.ControlDecoration;
import org.eclipse.jface.fieldassist.FieldDecorationRegistry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Control;

/**
 * Simple control decorator which visualizes the validation status of a binding
 * on a control assuming the binding's target observable is of type
 * {@link ISWTObservable} and {@link ISWTObservable#getWidget()} returns a
 * {@link Control} instance to be decorated. In addition, the staleness state of
 * a binding's validation status observable is also visualized on the control.
 */
public class ControlDecorator {

	private static final int DECORATION_POSITION = SWT.LEFT | SWT.TOP;

	private final Map bindingToDecorationMap = new HashMap();

	private IListChangeListener bindingsListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {
			ListDiff diff = event.diff;
			ListDiffEntry[] differences = diff.getDifferences();
			for (int i = 0; i < differences.length; i++) {
				ListDiffEntry listDiffEntry = differences[i];
				Binding binding = (Binding) listDiffEntry.getElement();
				if (listDiffEntry.isAddition()) {
					addBinding(binding);
				} else {
					removeBinding(binding);
				}
			}
		}
	};

	public void addDbc(DataBindingContext dbc) {
		IObservableList bindings = dbc.getBindings();
		for (Iterator iterator = bindings.iterator(); iterator.hasNext();) {
			Binding binding = (Binding) iterator.next();
			addBinding(binding);
		}
		bindings.addListChangeListener(bindingsListener);
	}

	private void addBinding(final Binding binding) {
		if (binding.getTarget() instanceof ISWTObservable) {
			ISWTObservable target = (ISWTObservable) binding.getTarget();
			if (target.getWidget() instanceof Control) {
				Control control = (Control) target.getWidget();
				final ControlDecoration decoration = new ControlDecoration(
						control, DECORATION_POSITION);

				binding.getValidationStatus().addValueChangeListener(
						new IValueChangeListener() {
							public void handleValueChange(ValueChangeEvent event) {
								updateDecoration(decoration, binding);
							}
						});

				binding.getValidationStatus().addStaleListener(
						new IStaleListener() {
							public void handleStale(StaleEvent staleEvent) {
								updateDecoration(decoration, binding);
							}
						});

				bindingToDecorationMap.put(binding, decoration);
				updateDecoration(decoration, binding);
			}
		}
	}

	private void removeBinding(Binding binding) {
		ControlDecoration decoration = (ControlDecoration) bindingToDecorationMap
				.get(binding);
		if (decoration != null) {
			decoration.hide();
			decoration.setDescriptionText(null);

			bindingToDecorationMap.remove(binding);
		}
	}

	private void updateDecoration(ControlDecoration decoration, Binding binding) {
		IObservableValue validation = binding.getValidationStatus();
		if (validation.isStale()) {
			showPendingUpdate(decoration);
			return;
		}

		IStatus validationStatus = (IStatus) validation.getValue();
		if (validationStatus.isOK()) {
			decoration.hide();
		} else {
			decoration.show();
			decoration.setImage(getStatusImage(validationStatus));
			decoration.setDescriptionText(validationStatus.getMessage());
		}
	}

	private void showPendingUpdate(final ControlDecoration decoration) {
		decoration.show();
		decoration.setImage(getImage(FieldDecorationRegistry.DEC_INFORMATION));
		decoration.setDescriptionText("Pending update...");
	}

	private Image getImage(String key) {
		return FieldDecorationRegistry.getDefault().getFieldDecoration(key)
				.getImage();
	}

	private Image getStatusImage(IStatus status) {
		if (status.matches(IStatus.ERROR)) {
			return getImage(FieldDecorationRegistry.DEC_ERROR);
		} else if (status.matches(IStatus.WARNING)) {
			return getImage(FieldDecorationRegistry.DEC_WARNING);
		} else if (status.matches(IStatus.INFO)) {
			return getImage(FieldDecorationRegistry.DEC_INFORMATION);
		}
		return null;
	}
}

Return to bug 233191

Lines 7-18 Link Here

(-)src/org/eclipse/core/tests/databinding/validation/MultiValidatorTest.java (-3 / +51 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
		10	* Ovidio Mallo - bug 233191
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.core.tests.databinding.validation;	13	package org.eclipse.core.tests.databinding.validation;
13		14
14	import org.eclipse.core.databinding.DataBindingContext;	15	import org.eclipse.core.databinding.DataBindingContext;
		16	import org.eclipse.core.databinding.observable.IStaleListener;
15	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
		18	import org.eclipse.core.databinding.observable.StaleEvent;
16	import org.eclipse.core.databinding.observable.value.IObservableValue;	19	import org.eclipse.core.databinding.observable.value.IObservableValue;
17	import org.eclipse.core.databinding.observable.value.WritableValue;	20	import org.eclipse.core.databinding.observable.value.WritableValue;
18	import org.eclipse.core.databinding.validation.MultiValidator;	21	import org.eclipse.core.databinding.validation.MultiValidator;
Lines 25-37 Link Here
25		28
26	public class MultiValidatorTest extends AbstractDefaultRealmTestCase {	29	public class MultiValidatorTest extends AbstractDefaultRealmTestCase {
27	private WritableValue dependency;	30	private WritableValue dependency;
28	private MultiValidator validator;	31	private TestMultiValidator validator;
29	private IObservableValue validationStatus;	32	private IObservableValue validationStatus;
30		33
31	protected void setUp() throws Exception {	34	protected void setUp() throws Exception {
32	super.setUp();	35	super.setUp();
33	dependency = new WritableValue(null, IStatus.class);	36	dependency = new WritableValue(null, IStatus.class);
34	validator = new MultiValidator() {	37	validator = new TestMultiValidator() {
35	protected IStatus validate() {	38	protected IStatus validate() {
36	return (IStatus) dependency.getValue();	39	return (IStatus) dependency.getValue();
37	}	40	}
Lines 58-64 Link Here
58		61
59	public void testGetValidationStatus_ExceptionThrownYieldsErrorStatus() {	62	public void testGetValidationStatus_ExceptionThrownYieldsErrorStatus() {
60	final RuntimeException e = new RuntimeException("message");	63	final RuntimeException e = new RuntimeException("message");
61	validator = new MultiValidator() {	64	validator = new TestMultiValidator() {
62	protected IStatus validate() {	65	protected IStatus validate() {
63	throw e;	66	throw e;
64	}	67	}
Lines 115-118 Link Here
115	assertEquals(target.getValue(), validated.getValue());	118	assertEquals(target.getValue(), validated.getValue());
116	assertFalse(validated.isStale());	119	assertFalse(validated.isStale());
117	}	120	}
		121
		122	public void testEnterExitStale_ValidationStatusStaleness() {
		123	StaleCounter staleCounter = new StaleCounter();
		124	validationStatus.addStaleListener(staleCounter);
		125
		126	assertEquals(0, staleCounter.count);
		127
		128	validator.enterStaleDelegate();
		129	assertEquals(1, staleCounter.count);
		130	assertTrue(validationStatus.isStale());
		131
		132	validator.exitStaleDelegate((IStatus) validationStatus.getValue());
		133	assertFalse(validationStatus.isStale());
		134	}
		135
		136	public void testEnterExitStale_ValidationStatusValue() {
		137	validator.enterStaleDelegate();
		138	IStatus status = ValidationStatus.error("done");
		139	validator.exitStaleDelegate(status);
		140	assertSame(status, validationStatus.getValue());
		141	}
		142
		143	/**
		144	* Simple extension of the MultiValidator class which is functionally
		145	* equivalent while making some methods accessible to the unit tests.
		146	*/
		147	private static abstract class TestMultiValidator extends MultiValidator {
		148
		149	void enterStaleDelegate() {
		150	enterStale();
		151	}
		152
		153	void exitStaleDelegate(IStatus status) {
		154	exitStale(status);
		155	}
		156	}
		157
		158	private static class StaleCounter implements IStaleListener {
		159
		160	int count;
		161
		162	public void handleStale(StaleEvent event) {
		163	count++;
		164	}
		165	}
118	}	166	}

Lines 61-66 Link Here

(-)src/org/eclipse/jface/tests/databinding/BindingTestSuite.java (-1 / +9 lines)
61	import org.eclipse.core.tests.internal.databinding.BindingStatusTest;	61	import org.eclipse.core.tests.internal.databinding.BindingStatusTest;
62	import org.eclipse.core.tests.internal.databinding.QueueTest;	62	import org.eclipse.core.tests.internal.databinding.QueueTest;
63	import org.eclipse.core.tests.internal.databinding.RandomAccessListIteratorTest;	63	import org.eclipse.core.tests.internal.databinding.RandomAccessListIteratorTest;
		64	import org.eclipse.core.tests.internal.databinding.UpdateExecutorTest;
		65	import org.eclipse.core.tests.internal.databinding.UpdateValidationObservableValueTest;
64	import org.eclipse.core.tests.internal.databinding.beans.BeanObservableListDecoratorTest;	66	import org.eclipse.core.tests.internal.databinding.beans.BeanObservableListDecoratorTest;
65	import org.eclipse.core.tests.internal.databinding.beans.BeanObservableSetDecoratorTest;	67	import org.eclipse.core.tests.internal.databinding.beans.BeanObservableSetDecoratorTest;
66	import org.eclipse.core.tests.internal.databinding.beans.BeanObservableValueDecoratorTest;	68	import org.eclipse.core.tests.internal.databinding.beans.BeanObservableValueDecoratorTest;
Lines 132-137 Link Here
132	import org.eclipse.jface.tests.databinding.viewers.ObservableSetContentProviderTest;	134	import org.eclipse.jface.tests.databinding.viewers.ObservableSetContentProviderTest;
133	import org.eclipse.jface.tests.databinding.viewers.ObservableSetTreeContentProviderTest;	135	import org.eclipse.jface.tests.databinding.viewers.ObservableSetTreeContentProviderTest;
134	import org.eclipse.jface.tests.databinding.viewers.ViewersObservablesTest;	136	import org.eclipse.jface.tests.databinding.viewers.ViewersObservablesTest;
		137	import org.eclipse.jface.tests.databinding.wizard.WizardPageSupportTest;
135	import org.eclipse.jface.tests.examples.databinding.mask.internal.EditMaskLexerAndTokenTest;	138	import org.eclipse.jface.tests.examples.databinding.mask.internal.EditMaskLexerAndTokenTest;
136	import org.eclipse.jface.tests.examples.databinding.mask.internal.EditMaskParserTest;	139	import org.eclipse.jface.tests.examples.databinding.mask.internal.EditMaskParserTest;
137	import org.eclipse.jface.tests.internal.databinding.swt.ButtonObservableValueTest;	140	import org.eclipse.jface.tests.internal.databinding.swt.ButtonObservableValueTest;
Lines 242-247 Link Here
242	addTestSuite(BindingStatusTest.class);	245	addTestSuite(BindingStatusTest.class);
243	addTestSuite(RandomAccessListIteratorTest.class);	246	addTestSuite(RandomAccessListIteratorTest.class);
244	addTestSuite(QueueTest.class);	247	addTestSuite(QueueTest.class);
		248	addTestSuite(UpdateExecutorTest.class);
		249	addTest(UpdateValidationObservableValueTest.suite());
245		250
246	// org.eclipse.core.tests.internal.databinding.conversion	251	// org.eclipse.core.tests.internal.databinding.conversion
247	addTestSuite(DateConversionSupportTest.class);	252	addTestSuite(DateConversionSupportTest.class);
Lines 332-338 Link Here
332	addTestSuite(ObservableSetContentProviderTest.class);	337	addTestSuite(ObservableSetContentProviderTest.class);
333	addTestSuite(ObservableSetTreeContentProviderTest.class);	338	addTestSuite(ObservableSetTreeContentProviderTest.class);
334	addTestSuite(ViewersObservablesTest.class);	339	addTestSuite(ViewersObservablesTest.class);
335		340
		341	// org.eclipse.jface.tests.databinding.wizard
		342	addTestSuite(WizardPageSupportTest.class);
		343
336	//org.eclipse.jface.tests.example.databinding.mask.internal	344	//org.eclipse.jface.tests.example.databinding.mask.internal
337	addTestSuite(EditMaskLexerAndTokenTest.class);	345	addTestSuite(EditMaskLexerAndTokenTest.class);
338	addTestSuite(EditMaskParserTest.class);	346	addTestSuite(EditMaskParserTest.class);

Added Link Here

(-)src/org/eclipse/core/tests/internal/databinding/UpdateValidationObservableValueTest.java (+134 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Ovidio Mallo and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Ovidio Mallo - initial API and implementation (bug 233191)
10	******************************************************************************/
11
12	package org.eclipse.core.tests.internal.databinding;
13
14	import junit.framework.Test;
15	import junit.framework.TestSuite;
16
17	import org.eclipse.core.databinding.observable.IObservable;
18	import org.eclipse.core.databinding.observable.IStaleListener;
19	import org.eclipse.core.databinding.observable.ObservableTracker;
20	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.StaleEvent;
22	import org.eclipse.core.databinding.observable.value.IObservableValue;
23	import org.eclipse.core.databinding.observable.value.IValueChangeListener;
24	import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
25	import org.eclipse.core.databinding.validation.ValidationStatus;
26	import org.eclipse.core.internal.databinding.UpdateValidationObservableValue;
27	import org.eclipse.core.runtime.IStatus;
28	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
29	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
30	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
31
32	/**
33	* @since 1.2
34	*/
35	public class UpdateValidationObservableValueTest extends
36	AbstractDefaultRealmTestCase {
37
38	public static Test suite() {
39	TestSuite suite = new TestSuite(
40	UpdateValidationObservableValueTest.class.getName());
41	suite.addTestSuite(UpdateValidationObservableValueTest.class);
42	suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));
43	return suite;
44	}
45
46	public void testStaleness() {
47	UpdateValidationObservableValueStub observable = new UpdateValidationObservableValueStub(
48	Realm.getDefault());
49
50	ValueChangeCounter valueChangeCounter = new ValueChangeCounter();
51	observable.addValueChangeListener(valueChangeCounter);
52
53	StaleCounter staleCounter = new StaleCounter();
54	observable.addStaleListener(staleCounter);
55
56	assertEquals(0, valueChangeCounter.count);
57	assertEquals(0, staleCounter.count);
58	assertFalse(observable.isStale());
59
60	observable.setStale(true);
61	assertEquals(0, valueChangeCounter.count);
62	assertEquals(1, staleCounter.count);
63	assertTrue(observable.isStale());
64
65	observable.setStale(false);
66	assertEquals(1, valueChangeCounter.count);
67	assertEquals(1, staleCounter.count);
68	assertFalse(observable.isStale());
69	}
70
71	/* package */static class Delegate extends
72	AbstractObservableValueContractDelegate {
73
74	public IObservableValue createObservableValue(Realm realm) {
75	return new UpdateValidationObservableValueStub(realm);
76	}
77
78	public void change(IObservable observable) {
79	IObservableValue observableValue = (IObservableValue) observable;
80	observableValue.setValue(createValue(observableValue));
81	}
82
83	public void setStale(IObservable observable, boolean stale) {
84	((UpdateValidationObservableValueStub) observable).setStale(stale);
85	}
86
87	public Object getValueType(IObservableValue observable) {
88	return IStatus.class;
89	}
90
91	public Object createValue(IObservableValue observable) {
92	IStatus status = (IStatus) observable.getValue();
93	return ValidationStatus.error(status.getMessage() + "a");
94	}
95	}
96
97	private static class UpdateValidationObservableValueStub extends
98	UpdateValidationObservableValue {
99
100	private boolean stale = false;
101
102	public UpdateValidationObservableValueStub(Realm realm) {
103	super(realm);
104	}
105
106	public boolean isStale() {
107	ObservableTracker.getterCalled(this);
108	return stale;
109	}
110
111	public void setStale(boolean stale) {
112	this.stale = stale;
113	updateStaleness();
114	}
115	}
116
117	private static class ValueChangeCounter implements IValueChangeListener {
118
119	int count;
120
121	public void handleValueChange(ValueChangeEvent event) {
122	count++;
123	}
124	}
125
126	private static class StaleCounter implements IStaleListener {
127
128	int count;
129
130	public void handleStale(StaleEvent event) {
131	count++;
132	}
133	}
134	}

Added Link Here

(-)src/org/eclipse/jface/tests/databinding/wizard/WizardPageSupportTest.java (+138 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Ovidio Mallo and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Ovidio Mallo - initial API and implementation (bug 233191)
10	******************************************************************************/
11
12	package org.eclipse.jface.tests.databinding.wizard;
13
14	import org.eclipse.core.databinding.DataBindingContext;
15	import org.eclipse.core.databinding.ValidationStatusProvider;
16	import org.eclipse.core.databinding.observable.Diffs;
17	import org.eclipse.core.databinding.observable.Observables;
18	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.core.databinding.observable.list.IObservableList;
20	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
21	import org.eclipse.core.databinding.observable.value.IObservableValue;
22	import org.eclipse.core.databinding.validation.ValidationStatus;
23	import org.eclipse.core.internal.commands.util.Util;
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.jface.databinding.wizard.WizardPageSupport;
26	import org.eclipse.jface.tests.databinding.AbstractSWTTestCase;
27	import org.eclipse.jface.wizard.IWizardPage;
28	import org.eclipse.jface.wizard.Wizard;
29	import org.eclipse.jface.wizard.WizardDialog;
30	import org.eclipse.jface.wizard.WizardPage;
31	import org.eclipse.swt.widgets.Composite;
32
33	/**
34	* @since 1.2
35	*/
36	public class WizardPageSupportTest extends AbstractSWTTestCase {
37
38	public void testPageCompleteOnValidationStaleness() {
39	IWizardPage page = new WizardPage("Page") {
40	public void createControl(Composite parent) {
41	setControl(parent);
42
43	ValidationObservable validation = new ValidationObservable();
44
45	DataBindingContext dbc = new DataBindingContext();
46	dbc.addValidationStatusProvider(new ValidationProvider(
47	validation));
48
49	WizardPageSupport.create(this, dbc);
50
51	assertTrue(isPageComplete());
52
53	validation.setStale(true);
54	assertFalse(isPageComplete());
55
56	validation.setStale(false);
57	assertTrue(isPageComplete());
58	}
59	};
60
61	loadWizardPage(page);
62	}
63
64	private void loadWizardPage(IWizardPage page) {
65	Wizard wizard = new Wizard() {
66	public boolean performFinish() {
67	return true;
68	}
69	};
70	wizard.addPage(page);
71
72	WizardDialog dialog = new WizardDialog(getShell(), wizard);
73	dialog.create();
74	}
75
76	private static class ValidationObservable extends AbstractObservableValue {
77
78	private Object value = ValidationStatus.ok();
79
80	private boolean stale = false;
81
82	public ValidationObservable() {
83	super(Realm.getDefault());
84	}
85
86	protected Object doGetValue() {
87	return value;
88	}
89
90	protected void doSetValue(Object value) {
91	Object oldValue = this.value;
92	this.value = value;
93	if (!Util.equals(oldValue, value)) {
94	fireValueChange(Diffs.createValueDiff(oldValue, value));
95	}
96	}
97
98	public boolean isStale() {
99	return stale;
100	}
101
102	public void setStale(boolean stale) {
103	if (this.stale != stale) {
104	this.stale = stale;
105	if (stale) {
106	fireStale();
107	} else {
108	fireValueChange(Diffs.createValueDiff(value, value));
109	}
110	}
111	}
112
113	public Object getValueType() {
114	return IStatus.class;
115	}
116	}
117
118	private static class ValidationProvider extends ValidationStatusProvider {
119
120	private final IObservableValue validation;
121
122	public ValidationProvider(IObservableValue validation) {
123	this.validation = validation;
124	}
125
126	public IObservableValue getValidationStatus() {
127	return validation;
128	}
129
130	public IObservableList getTargets() {
131	return Observables.emptyObservableList();
132	}
133
134	public IObservableList getModels() {
135	return Observables.emptyObservableList();
136	}
137	}
138	}

Lines 10-15 Link Here

(-)src/org/eclipse/core/databinding/Binding.java (-1 / +21 lines)
10	* Brad Reynolds - bug 159768	10	* Brad Reynolds - bug 159768
11	* Boris Bokowski - bug 218269	11	* Boris Bokowski - bug 218269
12	* Matthew Hall - bug 218269	12	* Matthew Hall - bug 218269
		13	* Ovidio Mallo - bug 233191
13	*******************************************************************************/	14	*******************************************************************************/
14		15
15	package org.eclipse.core.databinding;	16	package org.eclipse.core.databinding;
Lines 110-116 Link Here
110	* by the time this call returns.	111	* by the time this call returns.
111	*/	112	*/
112	public abstract void validateModelToTarget();	113	public abstract void validateModelToTarget();
113		114
		115	/**
		116	* Returns whether the updates performed by this binding are executed
		117	* asynchronously.
		118	*
		119	* <p>
		120	* By default, this method returns <code>false</code>. Subclasses will
		121	* typically want to overwrite this method to return whether <i>any</i> of
		122	* the binding's update strategies is intended to be run asynchronously.
		123	* However, subclasses may always decide not to execute the updates
		124	* asynchronously.
		125	* </p>
		126	*
		127	* @return whether the updates performed by this binding are executed
		128	* asynchronously.
		129	*/
		130	public boolean isAsync() {
		131	return false;
		132	}
		133
114	/**	134	/**
115	* Disposes of this Binding. Subclasses may extend, but must call super.dispose().	135	* Disposes of this Binding. Subclasses may extend, but must call super.dispose().
116	*/	136	*/

Lines 229-232 Link Here

(-)src/org/eclipse/core/databinding/UpdateListStrategy.java (+33 lines)
229	}	229	}
230	return Status.OK_STATUS;	230	return Status.OK_STATUS;
231	}	231	}
		232
		233	/**
		234	* Returns whether the list update defined by this strategy is intended to
		235	* be executed asynchronously.
		236	*
		237	* <p>
		238	* By default, this method returns <code>true</code> if and only if the
		239	* converter associated to this strategy is intended to be executed
		240	* asynchronously. Clients may extend without having to call the super
		241	* implementation.
		242	* </p>
		243	*
		244	* <p>
		245	* Note that even if this method returns <code>true</code>, there is no
		246	* guarantee as of whether the list update will indeed by executed
		247	* asynchronously or not.
		248	* </p>
		249	*
		250	* @return whether the list update defined by this strategy is intended to
		251	* be executed asynchronously.
		252	*
		253	* @see IConverter#isAsync()
		254	*/
		255	public boolean isAsync() {
		256	return isAsyncConverter(converter);
		257	}
		258
		259	private boolean isAsyncConverter(IConverter converter) {
		260	if (converter != null) {
		261	return converter.isAsync();
		262	}
		263	return false;
		264	}
232	}	265	}

Lines 14-30 Link Here

(-)src/org/eclipse/core/databinding/ListBinding.java (-17 / +73 lines)
14	import java.util.Collections;	14	import java.util.Collections;
15		15
16	import org.eclipse.core.databinding.observable.Diffs;	16	import org.eclipse.core.databinding.observable.Diffs;
		17	import org.eclipse.core.databinding.observable.ObservableTracker;
17	import org.eclipse.core.databinding.observable.list.IListChangeListener;	18	import org.eclipse.core.databinding.observable.list.IListChangeListener;
18	import org.eclipse.core.databinding.observable.list.IObservableList;	19	import org.eclipse.core.databinding.observable.list.IObservableList;
19	import org.eclipse.core.databinding.observable.list.ListChangeEvent;	20	import org.eclipse.core.databinding.observable.list.ListChangeEvent;
20	import org.eclipse.core.databinding.observable.list.ListDiff;	21	import org.eclipse.core.databinding.observable.list.ListDiff;
21	import org.eclipse.core.databinding.observable.list.ListDiffEntry;	22	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
22	import org.eclipse.core.databinding.observable.value.IObservableValue;	23	import org.eclipse.core.databinding.observable.value.IObservableValue;
23	import org.eclipse.core.databinding.observable.value.WritableValue;
24	import org.eclipse.core.internal.databinding.BindingStatus;	24	import org.eclipse.core.internal.databinding.BindingStatus;
		25	import org.eclipse.core.internal.databinding.UpdateExecutor;
		26	import org.eclipse.core.internal.databinding.UpdateRunnable;
		27	import org.eclipse.core.internal.databinding.UpdateValidationObservableValue;
25	import org.eclipse.core.runtime.IStatus;	28	import org.eclipse.core.runtime.IStatus;
26	import org.eclipse.core.runtime.MultiStatus;	29	import org.eclipse.core.runtime.MultiStatus;
27	import org.eclipse.core.runtime.Status;
28		30
29	/**	31	/**
30	* @since 1.0	32	* @since 1.0
Lines 34-42 Link Here
34		36
35	private UpdateListStrategy targetToModel;	37	private UpdateListStrategy targetToModel;
36	private UpdateListStrategy modelToTarget;	38	private UpdateListStrategy modelToTarget;
37	private IObservableValue validationStatusObservable;	39	private UpdateValidationObservableValue validationStatusObservable;
38	private boolean updatingTarget;	40	private boolean updatingTarget;
39	private boolean updatingModel;	41	private boolean updatingModel;
		42	private UpdateExecutor updateExecutor;
40		43
41	private IListChangeListener targetChangeListener = new IListChangeListener() {	44	private IListChangeListener targetChangeListener = new IListChangeListener() {
42	public void handleListChange(ListChangeEvent event) {	45	public void handleListChange(ListChangeEvent event) {
Lines 86-93 Link Here
86	}	89	}
87		90
88	protected void preInit() {	91	protected void preInit() {
89	validationStatusObservable = new WritableValue(context	92	updateExecutor = new UpdateExecutor(isAsync(), new Runnable() {
90	.getValidationRealm(), Status.OK_STATUS, IStatus.class);	93	public void run() {
		94	// If we are in asynchronous mode, we must update the staleness
		95	// of the validation observable upon every scheduling event.
		96	if (isAsync()) {
		97	validationStatusObservable.getRealm().exec(new Runnable() {
		98	public void run() {
		99	validationStatusObservable.updateStaleness();
		100	}
		101	});
		102	}
		103	}
		104	});
		105
		106	validationStatusObservable = new UpdateValidationObservableValue(
		107	context.getValidationRealm()) {
		108	public boolean isStale() {
		109	ObservableTracker.getterCalled(this);
		110	// If not in asynchronous mode, we never set the validation
		111	// observable to be stale.
		112	return ListBinding.this.isAsync()
		113	&& updateExecutor.hasPendingUpdates();
		114	}
		115	};
91	}	116	}
92		117
93	protected void postInit() {	118	protected void postInit() {
Lines 131-136 Link Here
131	// nothing for now	156	// nothing for now
132	}	157	}
133		158
		159	public boolean isAsync() {
		160	return targetToModel.isAsync() \|\| modelToTarget.isAsync();
		161	}
		162
134	/*	163	/*
135	* This method may be moved to UpdateListStrategy in the future if clients	164	* This method may be moved to UpdateListStrategy in the future if clients
136	* need more control over how the two lists are kept in sync.	165	* need more control over how the two lists are kept in sync.
Lines 140-149 Link Here
140	final UpdateListStrategy updateListStrategy,	169	final UpdateListStrategy updateListStrategy,
141	final boolean explicit, final boolean clearDestination) {	170	final boolean explicit, final boolean clearDestination) {
142	final int policy = updateListStrategy.getUpdatePolicy();	171	final int policy = updateListStrategy.getUpdatePolicy();
143	if (policy != UpdateListStrategy.POLICY_NEVER) {	172	if (policy == UpdateListStrategy.POLICY_NEVER)
144	if (policy != UpdateListStrategy.POLICY_ON_REQUEST \|\| explicit) {	173	return;
		174	if (policy == UpdateListStrategy.POLICY_ON_REQUEST && !explicit)
		175	return;
		176
		177	UpdateRunnable update = new UpdateRunnable() {
		178	public void run() {
		179	final ListDiffEntry[] diffEntries = diff.getDifferences();
		180	for (int i = 0; i < diffEntries.length; i++) {
		181	ListDiffEntry entry = diffEntries[i];
		182	if (entry.isAddition()) {
		183	diffEntries[i] = Diffs.createListDiffEntry(entry
		184	.getPosition(), entry.isAddition(),
		185	updateListStrategy.convert(entry.getElement()));
		186	}
		187	}
		188
145	destination.getRealm().exec(new Runnable() {	189	destination.getRealm().exec(new Runnable() {
146	public void run() {	190	public void run() {
		191	// If the update has been canceled before writing to the
		192	// destination observable, we do not set the validation
		193	// status, so we return outside the below try block.
		194	if (isCanceled()) {
		195	notifyDone();
		196	return;
		197	}
		198
147	if (destination == getTarget()) {	199	if (destination == getTarget()) {
148	updatingTarget = true;	200	updatingTarget = true;
149	} else {	201	} else {
Lines 155-183 Link Here
155	if (clearDestination) {	207	if (clearDestination) {
156	destination.clear();	208	destination.clear();
157	}	209	}
158	ListDiffEntry[] diffEntries = diff.getDifferences();
159	for (int i = 0; i < diffEntries.length; i++) {	210	for (int i = 0; i < diffEntries.length; i++) {
160	ListDiffEntry listDiffEntry = diffEntries[i];	211	ListDiffEntry listDiffEntry = diffEntries[i];
161	if (listDiffEntry.isAddition()) {	212	if (listDiffEntry.isAddition()) {
162	IStatus setterStatus = updateListStrategy	213	IStatus setterStatus = updateListStrategy
163	.doAdd(	214	.doAdd(destination, listDiffEntry
164	destination,	215	.getElement(),
165	updateListStrategy
166	.convert(listDiffEntry
167	.getElement()),
168	listDiffEntry.getPosition());	216	listDiffEntry.getPosition());
169		217
170	mergeStatus(multiStatus, setterStatus);	218	mergeStatus(multiStatus, setterStatus);
171	// TODO - at this point, the two lists	219	// TODO - at this point, the two lists
172	// will be out of sync if an error occurred...	220	// will be out of sync if an error
		221	// occurred...
173	} else {	222	} else {
174	IStatus setterStatus = updateListStrategy	223	IStatus setterStatus = updateListStrategy
175	.doRemove(destination,	224	.doRemove(destination,
176	listDiffEntry.getPosition());	225	listDiffEntry.getPosition());
177		226
178	mergeStatus(multiStatus, setterStatus);	227	mergeStatus(multiStatus, setterStatus);
179	// TODO - at this point, the two lists	228	// TODO - at this point, the two lists
180	// will be out of sync if an error occurred...	229	// will be out of sync if an error
		230	// occurred...
181	}	231	}
182	}	232	}
183	} finally {	233	} finally {
Lines 188-198 Link Here
188	} else {	238	} else {
189	updatingModel = false;	239	updatingModel = false;
190	}	240	}
		241
		242	notifyDone();
191	}	243	}
192	}	244	}
193	});	245	});
194	}	246	}
195	}	247	};
		248
		249	updateExecutor.execute(update, false);
196	}	250	}
197		251
198	/**	252	/**
Lines 209-214 Link Here
209	}	263	}
210		264
211	public void dispose() {	265	public void dispose() {
		266	updateExecutor.terminate();
		267
212	if (targetChangeListener != null) {	268	if (targetChangeListener != null) {
213	((IObservableList)getTarget()).removeListChangeListener(targetChangeListener);	269	((IObservableList)getTarget()).removeListChangeListener(targetChangeListener);
214	targetChangeListener = null;	270	targetChangeListener = null;

Lines 8-23 Link Here

(-)src/org/eclipse/core/databinding/ValueBinding.java (-72 / +150 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Matthew Hall - bug 220700	10	* Matthew Hall - bug 220700
		11	* Ovidio Mallo - bug 233191
11	*******************************************************************************/	12	*******************************************************************************/
12		13
13	package org.eclipse.core.databinding;	14	package org.eclipse.core.databinding;
14		15
		16	import org.eclipse.core.databinding.observable.ObservableTracker;
15	import org.eclipse.core.databinding.observable.value.IObservableValue;	17	import org.eclipse.core.databinding.observable.value.IObservableValue;
16	import org.eclipse.core.databinding.observable.value.IValueChangeListener;	18	import org.eclipse.core.databinding.observable.value.IValueChangeListener;
17	import org.eclipse.core.databinding.observable.value.ValueChangeEvent;	19	import org.eclipse.core.databinding.observable.value.ValueChangeEvent;
18	import org.eclipse.core.databinding.observable.value.WritableValue;
19	import org.eclipse.core.databinding.util.Policy;	20	import org.eclipse.core.databinding.util.Policy;
20	import org.eclipse.core.internal.databinding.BindingStatus;	21	import org.eclipse.core.internal.databinding.BindingStatus;
		22	import org.eclipse.core.internal.databinding.UpdateExecutor;
		23	import org.eclipse.core.internal.databinding.UpdateRunnable;
		24	import org.eclipse.core.internal.databinding.UpdateValidationObservableValue;
21	import org.eclipse.core.internal.databinding.Util;	25	import org.eclipse.core.internal.databinding.Util;
22	import org.eclipse.core.runtime.IStatus;	26	import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.core.runtime.MultiStatus;	27	import org.eclipse.core.runtime.MultiStatus;
Lines 30-38 Link Here
30	class ValueBinding extends Binding {	34	class ValueBinding extends Binding {
31	private final UpdateValueStrategy targetToModel;	35	private final UpdateValueStrategy targetToModel;
32	private final UpdateValueStrategy modelToTarget;	36	private final UpdateValueStrategy modelToTarget;
33	private WritableValue validationStatusObservable;	37	private UpdateValidationObservableValue validationStatusObservable;
34	private IObservableValue target;	38	private IObservableValue target;
35	private IObservableValue model;	39	private IObservableValue model;
		40	private UpdateExecutor updateExecutor;
36		41
37	private boolean updatingTarget;	42	private boolean updatingTarget;
38	private boolean updatingModel;	43	private boolean updatingModel;
Lines 78-85 Link Here
78	}	83	}
79		84
80	protected void preInit() {	85	protected void preInit() {
81	validationStatusObservable = new WritableValue(context	86	updateExecutor = new UpdateExecutor(isAsync(), new Runnable() {
82	.getValidationRealm(), Status.OK_STATUS, IStatus.class);	87	public void run() {
		88	// If we are in asynchronous mode, we must update the staleness
		89	// of the validation observable upon every scheduling event.
		90	if (isAsync()) {
		91	validationStatusObservable.getRealm().exec(new Runnable() {
		92	public void run() {
		93	validationStatusObservable.updateStaleness();
		94	}
		95	});
		96	}
		97	}
		98	});
		99
		100	validationStatusObservable = new UpdateValidationObservableValue(
		101	context.getValidationRealm()) {
		102	public boolean isStale() {
		103	ObservableTracker.getterCalled(this);
		104	// If not in asynchronous mode, we never set the validation
		105	// observable to be stale.
		106	return ValueBinding.this.isAsync()
		107	&& updateExecutor.hasPendingUpdates();
		108	}
		109	};
83	}	110	}
84		111
85	protected void postInit() {	112	protected void postInit() {
Lines 104-109 Link Here
104	}	131	}
105		132
106	/**	133	/**
		134	* Returns whether the updates performed by this binding are executed
		135	* asynchronously.
		136	*
		137	* <p>
		138	* This method returns <code>true</code> if and only if <i>any</i> of the
		139	* binding's update strategies is intended to be run asynchronously.
		140	* Thereby, the individual updates of this binding are always guaranteed to
		141	* be executed in the correct order, thus ensuring that the target and model
		142	* values will never get out of sync due to the asynchronous nature of the
		143	* updates.
		144	* </p>
		145	*
		146	* <p>
		147	* In case the updates are executed asynchronously, the staleness state of
		148	* the validation status observable can be used to determine whether there
		149	* are any pending updates. This allows for awaiting the termination of
		150	* those updates, if desired, by tracking the observable's staleness state.
		151	* </p>
		152	*
		153	* @return whether the updates performed by this binding are executed
		154	* asynchronously.
		155	*
		156	* @see UpdateValueStrategy#isAsync()
		157	*/
		158	public boolean isAsync() {
		159	return targetToModel.isAsync() \|\| modelToTarget.isAsync();
		160	}
		161
		162	/**
107	* Incorporates the provided <code>newStats</code> into the	163	* Incorporates the provided <code>newStats</code> into the
108	* <code>multieStatus</code>.	164	* <code>multieStatus</code>.
109	*	165	*
Lines 128-134 Link Here
128	final IObservableValue destination,	184	final IObservableValue destination,
129	final UpdateValueStrategy updateValueStrategy,	185	final UpdateValueStrategy updateValueStrategy,
130	final boolean explicit, final boolean validateOnly) {	186	final boolean explicit, final boolean validateOnly) {
131
132	final int policy = updateValueStrategy.getUpdatePolicy();	187	final int policy = updateValueStrategy.getUpdatePolicy();
133	if (policy == UpdateValueStrategy.POLICY_NEVER)	188	if (policy == UpdateValueStrategy.POLICY_NEVER)
134	return;	189	return;
Lines 137-214 Link Here
137		192
138	source.getRealm().exec(new Runnable() {	193	source.getRealm().exec(new Runnable() {
139	public void run() {	194	public void run() {
140	boolean destinationRealmReached = false;	195	// Get value
141	final MultiStatus multiStatus = BindingStatus.ok();	196	final Object value = source.getValue();
142	try {	197
143	// Get value	198	UpdateRunnable update = new UpdateRunnable() {
144	Object value = source.getValue();	199	public void run() {
145		200	boolean destinationRealmReached = false;
146	// Validate after get	201	final MultiStatus multiStatus = BindingStatus.ok();
147	IStatus status = updateValueStrategy	202	try {
148	.validateAfterGet(value);	203	// Validate after get
149	if (!mergeStatus(multiStatus, status))	204	IStatus status = updateValueStrategy
150	return;	205	.validateAfterGet(value);
151		206	if (!mergeStatus(multiStatus, status))
152	// Convert value	207	return;
153	final Object convertedValue = updateValueStrategy	208
154	.convert(value);	209	// Convert value
155		210	final Object convertedValue = updateValueStrategy
156	// Validate after convert	211	.convert(value);
157	status = updateValueStrategy	212
158	.validateAfterConvert(convertedValue);	213	// Validate after convert
159	if (!mergeStatus(multiStatus, status))	214	status = updateValueStrategy
160	return;	215	.validateAfterConvert(convertedValue);
161	if (policy == UpdateValueStrategy.POLICY_CONVERT	216	if (!mergeStatus(multiStatus, status))
162	&& !explicit)	217	return;
163	return;	218	if (policy == UpdateValueStrategy.POLICY_CONVERT
164		219	&& !explicit)
165	// Validate before set	220	return;
166	status = updateValueStrategy	221
167	.validateBeforeSet(convertedValue);	222	// Validate before set
168	if (!mergeStatus(multiStatus, status))	223	status = updateValueStrategy
169	return;	224	.validateBeforeSet(convertedValue);
170	if (validateOnly)	225	if (!mergeStatus(multiStatus, status))
171	return;	226	return;
172		227	if (validateOnly)
173	// Set value	228	return;
174	destinationRealmReached = true;	229
175	destination.getRealm().exec(new Runnable() {	230	// Set value
176	public void run() {	231	destinationRealmReached = true;
177	if (destination == target) {	232	destination.getRealm().exec(new Runnable() {
178	updatingTarget = true;	233	public void run() {
179	} else {	234	// If the update has been canceled before
180	updatingModel = true;	235	// writing to the destination observable, we
181	}	236	// do not set the validation status, so we
182	try {	237	// return outside the below try block.
183	IStatus setterStatus = updateValueStrategy	238	if (isCanceled()) {
184	.doSet(destination, convertedValue);	239	notifyDone();
185		240	return;
186	mergeStatus(multiStatus, setterStatus);	241	}
187	} finally {	242
188	if (destination == target) {	243	if (destination == target) {
189	updatingTarget = false;	244	updatingTarget = true;
190	} else {	245	} else {
191	updatingModel = false;	246	updatingModel = true;
		247	}
		248	try {
		249	IStatus setterStatus = updateValueStrategy
		250	.doSet(destination,
		251	convertedValue);
		252
		253	mergeStatus(multiStatus, setterStatus);
		254	} finally {
		255	if (destination == target) {
		256	updatingTarget = false;
		257	} else {
		258	updatingModel = false;
		259	}
		260	setValidationStatus(multiStatus);
		261	notifyDone();
		262	}
		263	}
		264	});
		265	} catch (Exception ex) {
		266	// This check is necessary as in 3.2.2 Status
		267	// doesn't accept a null message (bug 177264).
		268	String message = (ex.getMessage() != null) ? ex
		269	.getMessage() : ""; //$NON-NLS-1$
		270
		271	mergeStatus(multiStatus, new Status(IStatus.ERROR,
		272	Policy.JFACE_DATABINDING, IStatus.ERROR,
		273	message, ex));
		274	} finally {
		275	if (!destinationRealmReached) {
		276	// Set the validation status unless the update
		277	// has been canceled in the meanwhile.
		278	if (!isCanceled()) {
		279	setValidationStatus(multiStatus);
192	}	280	}
193	setValidationStatus(multiStatus);	281	notifyDone();
194	}	282	}
195	}	283	}
196	});
197	} catch (Exception ex) {
198	// This check is necessary as in 3.2.2 Status
199	// doesn't accept a null message (bug 177264).
200	String message = (ex.getMessage() != null) ? ex
201	.getMessage() : ""; //$NON-NLS-1$
202
203	mergeStatus(multiStatus, new Status(IStatus.ERROR,
204	Policy.JFACE_DATABINDING, IStatus.ERROR, message,
205	ex));
206	} finally {
207	if (!destinationRealmReached) {
208	setValidationStatus(multiStatus);
209	}	284	}
		285	};
210		286
211	}	287	updateExecutor.execute(update, !explicit);
212	}	288	}
213	});	289	});
214	}	290	}
Lines 230-235 Link Here
230	}	306	}
231		307
232	public void dispose() {	308	public void dispose() {
		309	updateExecutor.terminate();
		310
233	if (targetChangeListener != null) {	311	if (targetChangeListener != null) {
234	target.removeValueChangeListener(targetChangeListener);	312	target.removeValueChangeListener(targetChangeListener);
235	targetChangeListener = null;	313	targetChangeListener = null;

Lines 50-53 Link Here

(-)src/org/eclipse/core/databinding/conversion/IConverter.java (+15 lines)
50	* @return the converted object, of type {@link #getToType()}	50	* @return the converted object, of type {@link #getToType()}
51	*/	51	*/
52	public Object convert(Object fromObject);	52	public Object convert(Object fromObject);
		53
		54	/**
		55	* Returns whether the {@link #convert(Object)} method of this converter is
		56	* intended to be executed asynchronously.
		57	*
		58	* <p>
		59	* Note that even if this method returns <code>true</code>, there is no
		60	* guarantee as of whether the conversion will indeed by executed
		61	* asynchronously or not.
		62	* </p>
		63	*
		64	* @return whether the {@link #convert(Object)} method of this converter is
		65	* intended to be executed asynchronously.
		66	*/
		67	public boolean isAsync();
53	}	68	}

Lines 8-13 Link Here

(-)src/org/eclipse/core/databinding/validation/MultiValidator.java (-3 / +96 lines)
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 218269)	9	* Matthew Hall - initial API and implementation (bug 218269)
10	* Boris Bokowski - bug 218269	10	* Boris Bokowski - bug 218269
		11	* Ovidio Mallo - bug 233191
11	******************************************************************************/	12	******************************************************************************/
12		13
13	package org.eclipse.core.databinding.validation;	14	package org.eclipse.core.databinding.validation;
Lines 17-22 Link Here
17		18
18	import org.eclipse.core.databinding.ValidationStatusProvider;	19	import org.eclipse.core.databinding.ValidationStatusProvider;
19	import org.eclipse.core.databinding.observable.ChangeEvent;	20	import org.eclipse.core.databinding.observable.ChangeEvent;
		21	import org.eclipse.core.databinding.observable.Diffs;
20	import org.eclipse.core.databinding.observable.IChangeListener;	22	import org.eclipse.core.databinding.observable.IChangeListener;
21	import org.eclipse.core.databinding.observable.IObservable;	23	import org.eclipse.core.databinding.observable.IObservable;
22	import org.eclipse.core.databinding.observable.ObservableTracker;	24	import org.eclipse.core.databinding.observable.ObservableTracker;
Lines 30-35 Link Here
30	import org.eclipse.core.databinding.observable.map.IObservableMap;	32	import org.eclipse.core.databinding.observable.map.IObservableMap;
31	import org.eclipse.core.databinding.observable.set.IObservableSet;	33	import org.eclipse.core.databinding.observable.set.IObservableSet;
32	import org.eclipse.core.databinding.observable.value.IObservableValue;	34	import org.eclipse.core.databinding.observable.value.IObservableValue;
		35	import org.eclipse.core.databinding.observable.value.ValueDiff;
33	import org.eclipse.core.databinding.observable.value.WritableValue;	36	import org.eclipse.core.databinding.observable.value.WritableValue;
34	import org.eclipse.core.internal.databinding.observable.ValidatedObservableList;	37	import org.eclipse.core.internal.databinding.observable.ValidatedObservableList;
35	import org.eclipse.core.internal.databinding.observable.ValidatedObservableMap;	38	import org.eclipse.core.internal.databinding.observable.ValidatedObservableMap;
Lines 115-125 Link Here
115	*/	118	*/
116	public abstract class MultiValidator extends ValidationStatusProvider {	119	public abstract class MultiValidator extends ValidationStatusProvider {
117	private Realm realm;	120	private Realm realm;
118	private IObservableValue validationStatus;	121	private ValidationStatusObservableValue validationStatus;
119	private IObservableValue unmodifiableValidationStatus;	122	private IObservableValue unmodifiableValidationStatus;
120	private WritableList targets;	123	private WritableList targets;
121	private IObservableList unmodifiableTargets;	124	private IObservableList unmodifiableTargets;
122	private IObservableList models;	125	private IObservableList models;
		126	private boolean stale = false;
123		127
124	IListChangeListener targetsListener = new IListChangeListener() {	128	IListChangeListener targetsListener = new IListChangeListener() {
125	public void handleListChange(ListChangeEvent event) {	129	public void handleListChange(ListChangeEvent event) {
Lines 160-167 Link Here
160	Assert.isNotNull(realm, "Realm cannot be null"); //$NON-NLS-1$	164	Assert.isNotNull(realm, "Realm cannot be null"); //$NON-NLS-1$
161	this.realm = realm;	165	this.realm = realm;
162		166
163	validationStatus = new WritableValue(realm, ValidationStatus.ok(),	167	validationStatus = new ValidationStatusObservableValue(realm);
164	IStatus.class);
165		168
166	targets = new WritableList(realm, new ArrayList(), IObservable.class);	169	targets = new WritableList(realm, new ArrayList(), IObservable.class);
167	targets.addListChangeListener(targetsListener);	170	targets.addListChangeListener(targetsListener);
Lines 182-187 Link Here
182	* validation status of this MultiValidator. The returned observable is in	185	* validation status of this MultiValidator. The returned observable is in
183	* the same realm as this MultiValidator.	186	* the same realm as this MultiValidator.
184	*	187	*
		188	* <p>
		189	* In case the validation of this MultiValidator is performed
		190	* asynchronously, the staleness state of the validation status observable
		191	* can be used to determine whether there are any pending validations. This
		192	* allows for awaiting the termination of those validations, if desired, by
		193	* tracking the observable's staleness state.
		194	*
185	* @return an {@link IObservableValue} whose value is always the current	195	* @return an {@link IObservableValue} whose value is always the current
186	* validation status of this MultiValidator.	196	* validation status of this MultiValidator.
187	*/	197	*/
Lines 232-237 Link Here
232	protected abstract IStatus validate();	242	protected abstract IStatus validate();
233		243
234	/**	244	/**
		245	* Notifies the MultiValidator that the current validation status is being
		246	* computed asynchronously and is not available yet.
		247	*
		248	* <p>
		249	* Subclasses should invoke this method whenever the {@link #validate()
		250	* validation} is performed asynchronously. Calling this method guarantees
		251	* that the {@link #getValidationStatus() validation status observable} is
		252	* correctly set to be stale.
		253	*
		254	* <p>
		255	* Typically, this method should be called from within the
		256	* {@link #validate()} method when the asynchronous validation is started
		257	* while a reasonable validation status must always be returned to be used
		258	* while the pending validation has not terminated. Once the validation is
		259	* available, it can be passed to the MultiValidator by calling the
		260	* {@link #exitStale(IStatus)} method.
		261	*
		262	* <p>
		263	* Note: This method must be called from within the MultiValidator's realm.
		264	*
		265	* @see #exitStale(IStatus)
		266	* @see IObservableValue#isStale()
		267	*/
		268	protected final void enterStale() {
		269	stale = true;
		270	validationStatus.fireStale();
		271	}
		272
		273	/**
		274	* Notifies the MultiValidator that an asynchronous validation has
		275	* terminated which resulted in the given validation status.
		276	*
		277	* <p>
		278	* This method sets the given <code>status</code> as the current validation
		279	* status and sets the {@link #getValidationStatus() validation status
		280	* observable} to not be stale anymore.
		281	*
		282	* <p>
		283	* Note: This method must be called from within the MultiValidator's realm.
		284	*
		285	* @param status
		286	* the resulting status of the terminated validation.
		287	*
		288	* @see #enterStale()
		289	* @see IObservableValue#isStale()
		290	*/
		291	protected final void exitStale(IStatus status) {
		292	stale = false;
		293	Object oldStatus = validationStatus.getValue();
		294	validationStatus.setValue(status);
		295
		296	// In order to signal that the validation status observable is not stale
		297	// anymore, we must always fire a value change event, even if the
		298	// validation status has not changed. In the latter case, we must do so
		299	// explicitly.
		300	if (oldStatus.equals(status)) {
		301	validationStatus.fireValueChange(Diffs.createValueDiff(oldStatus,
		302	status));
		303	}
		304	}
		305
		306	/**
235	* Returns a wrapper {@link IObservableValue} which stays in sync with the	307	* Returns a wrapper {@link IObservableValue} which stays in sync with the
236	* given target observable only when the validation status is valid.	308	* given target observable only when the validation status is valid.
237	* Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or	309	* Statuses of {@link IStatus#OK OK}, {@link IStatus#INFO INFO} or
Lines 366-369 Link Here
366	super.dispose();	438	super.dispose();
367	}	439	}
368		440
		441	private class ValidationStatusObservableValue extends WritableValue {
		442
		443	public ValidationStatusObservableValue(Realm realm) {
		444	super(realm, ValidationStatus.ok(), IStatus.class);
		445	}
		446
		447	public boolean isStale() {
		448	ObservableTracker.getterCalled(this);
		449	return stale;
		450	}
		451
		452	protected void fireStale() {
		453	// Make the method accessible to the MultiValidator class.
		454	super.fireStale();
		455	}
		456
		457	protected void fireValueChange(ValueDiff diff) {
		458	// Make the method accessible to the MultiValidator class.
		459	super.fireValueChange(diff);
		460	}
		461	}
369	}	462	}