diff --git a/plugins/org.eclipse.sirius.doc/doc/Release_Notes.html b/plugins/org.eclipse.sirius.doc/doc/Release_Notes.html
index 7582ab2..cb7cb55 100644
--- a/plugins/org.eclipse.sirius.doc/doc/Release_Notes.html
+++ b/plugins/org.eclipse.sirius.doc/doc/Release_Notes.html
@@ -99,47 +99,42 @@
 		<h2 id="sirius5.0.0">Changes in Sirius 5.0.0</h2>
 		<h3 id="UserVisibleChanges">User-Visible Changes</h3>
 		<ul>
-			<li><span class="label label-success">Added</span> An experimental mode to serialize representations in a different file is available with system property 
-				<code>createRepresentationInSeparateResource=true</code>. That means all new representations will be saved, by default, in a separate file with *.srm extension.
-			</li>
 			<li><span class="label label-success">Added</span> An new 
 				<em>session editor</em> is available on 
-				<em>.aird</em> files. It provides an alternative, form-based GUI to visualize and manipulate sirius sessions which is not tied to the Modeling perspective or Model Explorer view. Sirius 5.0M6 includes a work-in-progress version of this new feature to encourage early community 
-				<a href="https://wiki.eclipse.org/Sirius/SessionEditor">feedback</a>. That version should be considered in alpha state in terms of stability an UI polish. By default, the new editor will automatically open when a session is opened, but this behavior can be disabled via a new preference in the 
-				<em>Sirius</em> category.
+				<em>.aird</em> files. It provides an alternative, form-based GUI to visualize and manipulate sirius sessions which is not tied to the Modeling perspective or Model Explorer view. See 
+				<a href="user/general/Aird_Editor.html">the editor&#8217;s documentation</a> for more details.
 			</li>
-			<li><span class="label label-info">Modified</span> The label alignment of Notes from the Palette has been modified from Juno to Luna or newer versions of Eclipse. The label alignment changed from TOP &amp; CENTER to MIDDLE &amp; LEFT. The initial alignment (TOP &amp; CENTER) has been restored.</li>
-			<li><span class="label label-info">Modified</span> The export diagram as images actions are now adapting the output resolution based on the diagram size, this leads to better resolution for small to medium diagrams (and also bigger file) and to an operation which is no longer failing with out of memory errors in case of very big diagrams.</li>
-			<li><span class="label label-info">Modified</span>The &#8220;straighten to&#8221; actions previously had a limitation concerning overlap detection. This is no longer the case. The previous known limitation was removed from the documentation (
+			<li><span class="label label-info">Modified</span> The label alignment of Notes from the Palette has been modified from Juno to Luna or newer versions of Eclipse. The label alignment had changed from 
+				<em>TOP</em> &amp; 
+				<em>CENTER</em> to 
+				<em>MIDDLE</em> &amp; 
+				<em>LEFT</em> (respectively). The initial alignment (
+				<em>TOP</em> &amp; 
+				<em>CENTER</em>) has been restored.
+			</li>
+			<li><span class="label label-info">Modified</span> The 
+				<em>Export diagram as images</em> action now adatps the output resolution based on the diagram size. This leads to better resolution for small to medium diagrams (and also bigger file) and to an operation which is no longer failing with out of memory errors in case of very big diagrams.
+			</li>
+			<li><span class="label label-info">Modified</span> The &#8220;straighten to&#8221; actions previously had a limitation concerning overlap detection. This is no longer the case. The previous known limitation has been removed from the documentation (
 				<i>In case of multi-selection, the overlap check is done in the current context of existing border nodes and not in the context of location of border nodes after each straighten edges.</i>).
 			</li>
-			<li><span class="label label-info">Modified</span>Decorators on diagram elements are drawn over all figures. If there is an overlap between a decorator of a figure A and another figure B that is over figure A, when user clicks on the decorator, the figure B is now selected (before it was the parent figure A).</li>
+			<li><span class="label label-info">Modified</span> Decorators on diagram elements are drawn on top of other figures. If there is an overlap between a decorator of a figure A and another figure B that is over figure A, when user clicks on the decorator, the figure B is now selected (before it was the parent figure A).</li>
 		</ul>
 		<h3 id="SpecifierVisibleChanges">Specifier-Visible Changes</h3>
 		<ul>
-			<li><span class="label label-success">Added</span> It is now possible to create one or multiple pre-configured widget(s) in a group if its domain class and if the meta-models of the properties view containing it have been specified.</li>
+			<li><span class="label label-success">Added</span> It is now possible to automatically create one or several pre-configured widget(s) in a group if its domain class and if the meta-models of the properties view containing it have been specified. The widget(s) created will be infered from the features in the domain class (e.g. a properly configured 
+				<em>Checkbox</em> widget will be created for boolean attributes).
+			</li>
 			<li><span class="label label-success">Added</span> Property Views definitions now support extending and overriding Properties View Descriptions without modifying the original. See 
 				<a href="specifier/properties/Properties_View_Description.html#extensibility_features">the documentation</a> for details.
 			</li>
-			<li><span class="label label-info">Modified</span> The transient layer has been introduced in Sirius 5.0. (Refer to 
-				<a href="specifier/diagrams/Diagrams.html#Transientlayer">Sirius Specifier</a> and 
-				<a href="user/diagrams/Diagrams.html#transientLayer">Sirius User</a> documentation in Diagram chapter). Transient layer is an additional layer containing only decorations or tools. If you have such layer in your VSM, users may encounter some unexpected behaviors. If the layer is not 
-				<em>active by default</em> then it will not be applied when opening your diagram even if it was activated before. If the layer is 
-				<em>active by default</em> then it will be automatically applied when opening your diagram. We consider this behavior as a known limitation and an enhancement may be done in a further release. In the meantime, there is a workaround which consists to add a fake mapping (that is any mapping with its fields empty) so that the layer will not be considered as transient.
-			</li>
-			<li><span class="label label-info">Modified</span> The tab used to configure the metamodels used by the Properties view description is now using the same interface as the metamodels tab used to configure the representations.</li>
-			<li><span class="label label-info">Modified</span> The 
-				<code>package::Class</code> syntax for domain classes and type names in the VSM is now fully supported and the new default. It means this syntax is interpreted by Sirius and completion is provided for it when the first 
-				<code>:</code> character is entered. The legacy syntax 
-				<code>package.Class</code> is still supported for compatibility.
-			</li>
 			<li><span class="label label-success">Added</span> New model operations are available. You can now open a 
 				<a href="specifier/general/Model_Operations.html#dialog">dialog</a> or a 
 				<a href="specifier/general/Model_Operations.html#wizard">wizard</a> thanks to new dedicated model operations leveraging the Properties View language. You can also create new variable with the new 
 				<em>Let</em> model operation, see its 
 				<a href="specifier/general/Model_Operations.html#let">documentation</a> for more details.
 			</li>
-			<li><span class="label label-success">Added</span> You can now create 
+			<li><span class="label label-success">Added</span> In Property Views definitions, you can now create 
 				<em>Toolbar Actions</em> on pages and groups in order to define small buttons in their toolbars.
 			</li>
 			<li><span class="label label-success">Added</span> 
@@ -159,6 +154,18 @@
 				<em>Categories</em> have been added in order to organize the pages and groups of the 
 				<em>Properties</em> DSL.
 			</li>
+			<li><span class="label label-info">Modified</span> The notion of transient layer has been introduced in Sirius 5.0. (Refer to 
+				<a href="specifier/diagrams/Diagrams.html#Transientlayer">Sirius Specifier</a> and 
+				<a href="user/diagrams/Diagrams.html#transientLayer">Sirius User</a> documentation in Diagram chapter). A transient layer is an additional layer containing only decorations or tools. If you have such layer in your VSM, users may encounter some unexpected behaviors. If the layer is not 
+				<em>active by default</em> then it will not be applied when opening your diagram even if it was activated before. If the layer is 
+				<em>active by default</em> then it will be automatically applied when opening your diagram. We consider this behavior as a known limitation and an enhancement may be done in a further release. In the meantime, there is a workaround which consists to add a fake mapping (that is any mapping with its fields empty) so that the layer will not be considered as transient.
+			</li>
+			<li><span class="label label-info">Modified</span> The tab used to configure the metamodels used by the Properties view description is now using the same interface as the metamodels tab used to configure the representations.</li>
+			<li><span class="label label-info">Modified</span> The 
+				<code>package::Class</code> syntax for domain classes and type names in the VSM is now fully supported and the new default. It means this syntax is interpreted by Sirius and completion is provided for it when the first 
+				<code>:</code> character is entered. The legacy syntax 
+				<code>package.Class</code> is still supported for compatibility.
+			</li>
 			<li><span class="label label-info">Modified</span> The organization of the contextual actions in the odesign for the 
 				<em>Properties</em> DSL has been improved.
 			</li>
@@ -183,7 +190,7 @@
 			</li>
 			<li><span class="label label-success">Added</span> A new extension point, 
 				<code>org.eclipse.sirius.common.package_meta_data</code> has been added. It can be used to associate user-oriented meta-data to Ecore metamodels, identified by their 
-				<code>nsURI</code>: a user-oriented name/label (as opposed to the technical nsURI), a (short) description/documentation, and a list of suggested EClasses defined in the EPackage that are good candidates as root model elements.
+				<code>nsURI</code>: a user-oriented name/label (as opposed to the technical nsURI), a (short) description/documentation, and a list of suggested EClasses defined in the EPackage that are good candidates as root model elements. These meta-data are currently used only in the generic model creation wizard integrated in the aird editor.
 			</li>
 		</ul>
 		<h4 id="Changesinorg.eclipse.sirius.common.ui">Changes in 
@@ -199,6 +206,10 @@
 			<code>org.eclipse.sirius</code> 
 		</h4>
 		<ul>
+			<li><span class="label label-success">Added</span> An experimental mode to serialize representations in a different file is available with system property 
+				<code>createRepresentationInSeparateResource=true</code>. That means all new representations will be saved, when this property is enabled, in a separate file with 
+				<code>*.srm</code> extension.
+			</li>
 			<li><span class="label label-success">Added</span> The method 
 				<code>org.eclipse.sirius.business.api.dialect.DialectServices.canCreate(EObject, RepresentationDescription, boolean)</code> has been added to better control the checks done by already existing 
 				<code>org.eclipse.sirius.business.api.dialect.DialectServices.canCreate(EObject, RepresentationDescription)</code> method. The new boolean allow to deactivate the check verifying that the viewpoint of the given description must be activated so the method can return true.
diff --git a/plugins/org.eclipse.sirius.doc/doc/Release_Notes.textile b/plugins/org.eclipse.sirius.doc/doc/Release_Notes.textile
index 214105a..575bc4a 100644
--- a/plugins/org.eclipse.sirius.doc/doc/Release_Notes.textile
+++ b/plugins/org.eclipse.sirius.doc/doc/Release_Notes.textile
@@ -8,30 +8,28 @@
 
 h3. User-Visible Changes
 
-* <span class="label label-success">Added</span> An experimental mode to serialize representations in a different file is available with system property @createRepresentationInSeparateResource=true@. That means all new representations will be saved, by default, in a separate file with *.srm extension.
-* <span class="label label-success">Added</span> An new _session editor_ is available on _.aird_ files. It provides an alternative, form-based GUI to visualize and manipulate sirius sessions which is not tied to the Modeling perspective or Model Explorer view. Sirius 5.0M6 includes a work-in-progress version of this new feature to encourage early community "feedback":https://wiki.eclipse.org/Sirius/SessionEditor. That version should be considered in alpha state in terms of stability an UI polish. By default, the new editor will automatically open when a session is opened, but this behavior can be disabled via a new preference in the _Sirius_ category.
-* <span class="label label-info">Modified</span> The label alignment of Notes from the Palette has been modified from Juno to Luna or newer versions of Eclipse. The label alignment changed from TOP & CENTER to MIDDLE & LEFT. The initial alignment (TOP & CENTER) has been restored.
-* <span class="label label-info">Modified</span> The export diagram as images actions are now adapting the output resolution based on the diagram size, this leads to better resolution for small to medium diagrams (and also bigger file) and to an operation which is no longer failing with out of memory errors in case of very big diagrams.
-* <span class="label label-info">Modified</span>The "straighten to" actions previously had a limitation concerning overlap detection. This is no longer the case. The previous known limitation was removed from the documentation (__In case of multi-selection, the overlap check is done in the current context of existing border nodes and not in the context of location of border nodes after each straighten edges.__).
-* <span class="label label-info">Modified</span>Decorators on diagram elements are drawn over all figures. If there is an overlap between a decorator of a figure A and another figure B that is over figure A, when user clicks on the decorator, the figure B is now selected (before it was the parent figure A).
+* <span class="label label-success">Added</span> An new _session editor_ is available on _.aird_ files. It provides an alternative, form-based GUI to visualize and manipulate sirius sessions which is not tied to the Modeling perspective or Model Explorer view. See "the editor's documentation":user/general/Aird_Editor.html for more details.
+* <span class="label label-info">Modified</span> The label alignment of Notes from the Palette has been modified from Juno to Luna or newer versions of Eclipse. The label alignment had changed from _TOP_ & _CENTER_ to _MIDDLE_ & _LEFT_ (respectively). The initial alignment (_TOP_ & _CENTER_) has been restored.
+* <span class="label label-info">Modified</span> The _Export diagram as images_ action now adatps the output resolution based on the diagram size. This leads to better resolution for small to medium diagrams (and also bigger file) and to an operation which is no longer failing with out of memory errors in case of very big diagrams.
+* <span class="label label-info">Modified</span> The "straighten to" actions previously had a limitation concerning overlap detection. This is no longer the case. The previous known limitation has been removed from the documentation (__In case of multi-selection, the overlap check is done in the current context of existing border nodes and not in the context of location of border nodes after each straighten edges.__).
+* <span class="label label-info">Modified</span> Decorators on diagram elements are drawn on top of other figures. If there is an overlap between a decorator of a figure A and another figure B that is over figure A, when user clicks on the decorator, the figure B is now selected (before it was the parent figure A).
 
 h3. Specifier-Visible Changes
 
-* <span class="label label-success">Added</span> It is now possible to create one or multiple pre-configured widget(s) in a group if its domain class and if the meta-models of the properties view containing it have been specified.
+* <span class="label label-success">Added</span> It is now possible to automatically create one or several pre-configured widget(s) in a group if its domain class and if the meta-models of the properties view containing it have been specified. The widget(s) created will be infered from the features in the domain class (e.g. a properly configured _Checkbox_ widget will be created for boolean attributes).
 * <span class="label label-success">Added</span> Property Views definitions now support extending and overriding Properties View Descriptions without modifying the original. See "the documentation":specifier/properties/Properties_View_Description.html#extensibility_features for details.
-* <span class="label label-info">Modified</span> The transient layer has been introduced in Sirius 5.0. (Refer to "Sirius Specifier":specifier/diagrams/Diagrams.html#Transientlayer and "Sirius User":user/diagrams/Diagrams.html#transientLayer documentation in Diagram chapter). Transient layer is an additional layer containing only decorations or tools. If you have such layer in your VSM, users may encounter some unexpected behaviors. If the layer is not _active by default_ then it will not be applied when opening your diagram even if it was activated before. If the layer is _active by default_ then it will be automatically applied when opening your diagram. We consider this behavior as a known limitation and an enhancement may be done in a further release. In the meantime, there is a workaround which consists to add a fake mapping (that is any mapping with its fields empty) so that the layer will not be considered as transient.
-* <span class="label label-info">Modified</span> The tab used to configure the metamodels used by the Properties view description is now using the same interface as the metamodels tab used to configure the representations.
-* <span class="label label-info">Modified</span> The @package::Class@ syntax for domain classes and type names in the VSM is now fully supported and the new default. It means this syntax is interpreted by Sirius and completion is provided for it when the first @:@ character is entered. The legacy syntax @package.Class@ is still supported for compatibility.
 * <span class="label label-success">Added</span> New model operations are available. You can now open a "dialog":specifier/general/Model_Operations.html#dialog or a "wizard":specifier/general/Model_Operations.html#wizard thanks to new dedicated model operations leveraging the Properties View language. You can also create new variable with the new _Let_ model operation, see its "documentation":specifier/general/Model_Operations.html#let for more details.
-* <span class="label label-success">Added</span> You can now create _Toolbar Actions_ on pages and groups in order to define small buttons in their toolbars.
+* <span class="label label-success">Added</span> In Property Views definitions, you can now create _Toolbar Actions_ on pages and groups in order to define small buttons in their toolbars.
 * <span class="label label-success">Added</span> _Buttons_ and _Widget Actions_ can now use an image along with a label thanks to the new _Image expression_.
 * <span class="label label-success">Added</span> It is now possible to execute some behavior when the end users will click on the _Reference Widget_ thanks to the addition of an _Initial Operation_.
 * <span class="label label-success">Added</span> You can indicate that a _Dynamic Mapping For_ should force the refresh of the user interface with the _Force Refresh_ property.
 * <span class="label label-success">Added</span> _Categories_ have been added in order to organize the pages and groups of the _Properties_ DSL.
+* <span class="label label-info">Modified</span> The notion of transient layer has been introduced in Sirius 5.0. (Refer to "Sirius Specifier":specifier/diagrams/Diagrams.html#Transientlayer and "Sirius User":user/diagrams/Diagrams.html#transientLayer documentation in Diagram chapter). A transient layer is an additional layer containing only decorations or tools. If you have such layer in your VSM, users may encounter some unexpected behaviors. If the layer is not _active by default_ then it will not be applied when opening your diagram even if it was activated before. If the layer is _active by default_ then it will be automatically applied when opening your diagram. We consider this behavior as a known limitation and an enhancement may be done in a further release. In the meantime, there is a workaround which consists to add a fake mapping (that is any mapping with its fields empty) so that the layer will not be considered as transient.
+* <span class="label label-info">Modified</span> The tab used to configure the metamodels used by the Properties view description is now using the same interface as the metamodels tab used to configure the representations.
+* <span class="label label-info">Modified</span> The @package::Class@ syntax for domain classes and type names in the VSM is now fully supported and the new default. It means this syntax is interpreted by Sirius and completion is provided for it when the first @:@ character is entered. The legacy syntax @package.Class@ is still supported for compatibility.
 * <span class="label label-info">Modified</span> The organization of the contextual actions in the odesign for the _Properties_ DSL has been improved.
 * <span class="label label-info">Modified</span> Most of the concepts of the _Properties_ DSL can now have an identifier, a label and some documentation.
 
-
 h3. Developer-Visible Changes
 
 h4. Translation Keys Changes
@@ -42,7 +40,7 @@
 
 * <span class="label label-success">Added</span> @org.eclipse.sirius.common.tools.api.util.SiriusCrossReferenceAdapterImpl.setFeatureToBeCrossReferencedWhiteList(Collection<EReference>)@ to set a white list of references that must be referenced even if the reference is derived.
 * <span class="label label-success">Added</span> @org.eclipse.sirius.common.tools.api.util.SiriusCrossReferenceAdapterImpl.isIncluded(EReference)@ has been overridden to consider features in the white list.
-* <span class="label label-success">Added</span> A new extension point, @org.eclipse.sirius.common.package_meta_data@ has been added. It can be used to associate user-oriented meta-data to Ecore metamodels, identified by their @nsURI@: a user-oriented name/label (as opposed to the technical nsURI), a (short) description/documentation, and a list of suggested EClasses defined in the EPackage that are good candidates as root model elements.
+* <span class="label label-success">Added</span> A new extension point, @org.eclipse.sirius.common.package_meta_data@ has been added. It can be used to associate user-oriented meta-data to Ecore metamodels, identified by their @nsURI@: a user-oriented name/label (as opposed to the technical nsURI), a (short) description/documentation, and a list of suggested EClasses defined in the EPackage that are good candidates as root model elements. These meta-data are currently used only in the generic model creation wizard integrated in the aird editor.
 
 h4. Changes in @org.eclipse.sirius.common.ui@ 
 
@@ -50,6 +48,7 @@
 
 h4. Changes in @org.eclipse.sirius@ 
 
+* <span class="label label-success">Added</span> An experimental mode to serialize representations in a different file is available with system property @createRepresentationInSeparateResource=true@. That means all new representations will be saved, when this property is enabled, in a separate file with @*.srm@ extension.
 * <span class="label label-success">Added</span> The method @org.eclipse.sirius.business.api.dialect.DialectServices.canCreate(EObject, RepresentationDescription, boolean)@ has been added to better control the checks done by already existing @org.eclipse.sirius.business.api.dialect.DialectServices.canCreate(EObject, RepresentationDescription)@ method. The new boolean allow to deactivate the check verifying that the viewpoint of the given description must be activated so the method can return true.
 * <span class="label label-success">Added</span> The @org.eclipse.sirius.viewpoint.description.DAnnotation.references@ feature has been added. It allows to have some information without having to search them into the entire model of the Sirius session. Ideally only elements from semantic resources of the session should be referenced or else it may broke the session behavior either because resolving too soon EObject in the session or because adding a resource that is not known by Sirius session.
 * <span class="label label-success">Added</span> @org.eclipse.sirius.business.api.query.EObjectQuery.getImpactedRepDescriptorFromDAnnotationData()@ method has been added to help retrieve the @DRepresentationDescriptors@ which owned @DAnnotation@ are referencing a given @EObject@ with @DAnnotation.references@.
