<?xml version='1.0' encoding='utf-8' ?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
		<title>reference</title>
		<link type="text/css" rel="stylesheet" href="../assets/css/stylesheet.css"/>
	</head>
	<body>
		<h2 id="Reference">Reference</h2>
		<h3 id="description">Description</h3>
		<p>The reference widget is used to edit mono-valued and multi-valued references. On top of the common properties of all widgets (identifier, labelExpression, helpExpression, isEnabledExpression, propertyValidationRules), it has the following properties:</p>
		<ul>
			<li>referenceNameExpression: This expression is used to compute the name of the reference to be displayed. This expression must return a string.</li>
			<li>referenceOwnerExpression: This expression is used to compute the EObject used to compute the value of the reference. By default, the EObject contained in the variable 
				<code>self</code> will be used. This expression must return an 
				<code>org.eclipse.emf.ecore.EObject</code>.
			</li>
			<li>style: The style of the reference widget.</li>
			<li>conditionalStyles: All the conditional styles of the reference widget.</li>
		</ul>
		<h3 id="editanedreference">Edit an EReference named children</h3>
		<p>In order to edit an EReference named 
			<code>children</code>, we can create a reference using the following configuration:
		</p>
		<ul>
			<li>referenceNameExpression: 
				<code>aql:'children'</code>
			</li>
		</ul>
		<p>All the configuration of the reference widget will be based on the EMF Edit framework. As such, you can customize the label, choice of values, images etc by modifying or extending the code generated for the edit part of your metamodel.</p>
		<p>EEF does not provide a default interpreter but you can easily configure EEF to be used with the AQL interpreter. In the integration of EEF with the AQL interpreter, you can register additional services, written in Java, in which you can expose to AQL new operations.</p>
	</body>
</html>