<!-- 	This document is provided as a template along with some guidance for creating	your project proposal. This is just a template. Feel free to change it as	you see fit (add sections, remove section). We feel, however, that the	suggestions represented in this document represent the reasonable minimum	amount of information to move forward.		Please keep the formatting in this document simple. Please do not edit 	this document in Microsoft Word as it adds huge piles of markup that make	it difficult to restyle.		More information is available here:		http://wiki.eclipse.org/Development_Resources/HOWTO/Pre-Proposal_Phase		Direct any questions about this template to emo@eclipse.org --><html><head><!-- 	Include the title here. We will parse it out of here and include it on the	rendered webpage. Do not duplicate the title within the text of your page. --><title>Gendoc</title></head><!-- 	We make use of the 'classic' HTML Definition List (dl) tag to specify	committers. I know... you haven't seen this tag in a long while... --><style>dt {	display: list-item;	list-style-position: outside;	list-style-image:		url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);	margin-left: 16px;}dd {	margin-left: 25px;	margin-bottom: 5px;}</style><body>	<p>		Gendoc project is a proposed open source project under the <a			href="http://www.eclipse.org/modeling/">Eclipse Modeling Project</a>.	</p>	<!-- 	The communication channel must be specified. Typically, this is the	"Proposals" forum. In general, you don't need to change this. -->	<p>		This proposal is in the Project Proposal Phase (as defined in the		Eclipse Development Process) and is written to declare its intent and		scope. We solicit additional participation and input from the Eclipse		community. Please send all feedback to the <a			href="http://www.eclipse.org/forums/eclipse.proposals">Eclipse			Proposals</a> Forum.	</p>	<h2>Background</h2>	<!-- 	Optionally provide the background that has lead you to creating this project. -->	<p>Model-driven engineering and Model-based development technologies are	more and more used but documentation is still necessary as it is	generally part of the contract agreement. The idea is to keep only one	repository&mdash;the model&mdash;and to generate document from it.</p>	<p>The main issue of writing documentation linked to a model and	diagrams is the synchronization between the document content and the	model content, that can be solved by generation from models. The other	issue is the style of the generated document, that must often fit	exactly an industrial template.</p>	<p> Gendoc has been developed in order to offer an Open Source	solution to both problems by generating a document from a document	template written directly in the target format (OpenXML or	OpenDocument), using EMF models as datasources : the generated document	keeps both style and model content synchronization.</p>	<h2>Scope</h2>	<!-- 	All projects must have a well-defined scope. Describe, concisely, what	is in-scope and (optionally) what is out-of-scope. An Eclipse project	cannot have an open-ended scope. -->	<p>Gendoc generates documentation for EMF models using document templates	in formats such as OpenOffice Writer (.odt) or Microsoft Word (.docx).</p>	<p>Generated documents display data extracted from the model with	features such as:</p>	<ul>		<li>styled text</li>		<li>images and diagrams</li>		<li>tables</li>		<li>bookmarks and hyperlinks</li>	</ul>	<p>The framework can be extended to add custom generation	facilities.</p>	<h2>Description</h2>	<!-- 	Describe the project here. Be concise, but provide enough information that	somebody who doesn't already know very much about your project idea or domain	has at least a fighting chance of understanding its purpose. -->	<p>Gendoc extracts data from EMF models and generates documents that fully	respect the appearance of your document template.</p>	<p>The generation can be performed in a few steps:</p>	<table>		<tr>			<td><img src='1.png' /></td>			<td>Get or write a standard template document in OpenOffice				Writer (.odt) or Microsoft Word (.docx) format,</td>		</tr>		<tr>			<td><img src='2.png' /></td>			<td>Add script sections to get dynamic content from models :				each dynamic section of the template contains a script written in				M2T Acceleo language,</td>		</tr>		<tr>			<td><img src='3.png' /></td>			<td>Reference the model as datasource,</td>		</tr>		<tr>			<td><img src='4.png' /></td>			<td>Launch the generation directly from the template</td>		</tr>		<tr>			<td><img src='5.png' /></td>			<td>The generation result fully respects the template document,				with all dynamic sections filled with model content</td>		</tr>	</table>	<p>		<img src="gendoc_generation_details.png" width="400"/>	</p>	<p>Styles defined in the template are kept after generation, both		on static and dynamic parts.</p>	<p>Gendoc is currently used in several contexts (avionics, space, public	services) to produce various kinds of documentation:</p>	<ul>		<li>Specification or design document from UML or SysML models</li>		<li>Requirement document from Req-IF models</li>		<li>Test plan from a model containing Test scenarii</li>		<li>Interface configuration document</li>		<li>Data structure description from specific EMF models</li>	</ul>	<h2>Why Eclipse?</h2>	<!-- 	Answer these two questions:	What value does this project bring to the Eclipse	community? What value do you expect to obtain from hosting your project at Eclipse?		What value do you get by having your project at Eclipse over and above the value	of hosting at Eclipse Labs? -->	<p>This project is based on top of Eclipse-based technologies : EMF and	M2T technologies (compatible with M2T Acceleo for now), and it is	already compatible with Eclipse MDT Papyrus through a dedicated	extension.</p>	<h2>Relationship with other Eclipse Projects</h2>	<p>Gendoc has links with EMF and Acceleo as they are key technologies used	to define queries and extract data from models. We can also mention	links with GMF so that we can generate images from GMF editors. And	links with Papyrus so that we can generate images from Papyrus diagrams	or extract documentation from UML comments.</p>	<h2>Initial Contribution</h2>	<!-- 	Projects are expected to arrive at Eclipse with existing code.		Describe the existing code that will be contributed to the project. Please provide	a couple of paragraphs describing the code with modest detail, including important	information like code ownership (who holds the copyright?), and some consideration	of community that exists around the code. Include a listing of third-party libraries 	and associated licenses. -->	<p><a href="http://www.topcased.org">TOPCASED</a> is offering Gendoc as	initial code base. See	<a href="http://topcased-gendoc.gforge.enseeiht.fr/">http://topcased-gendoc.gforge.enseeiht.fr/</a>.</p>	<h3>Third party libraries :</h3>	<ul>		<li>JTidy (MIT license : <a			href="http://jtidy.sourceforge.net/license.html">http://jtidy.sourceforge.net/license.html</a>)		</li>	</ul>	<h2>Legal Issues</h2>	<!-- 	Please describe any potential legal issues in this section. Does somebody else	own the trademark to the project name? Is there some issue that prevents you	from licensing the project under the Eclipse Public License? Are parts of the 	code available under some other license? Are there any LGPL/GPL bits that you	absolutely require? -->	<p>All contributions will be distributed under the Eclipse Public License.</p>	<h2>Committers</h2>	<!-- 	List any initial committers that should be provisioned along with the	new project. Include affiliation, but do not include email addresses at	this point. -->	<p>The following individual is proposed as leader of the project:</p>	<dl>		<dt>Anne HAUGOMMARD, Atos</dt>		<dd>She is commiter on several TOPCASED components and is the			main contributor for Gendoc.</dd>	</dl>	<p>The following individuals are proposed as initial committers to		the project:</p>	<dl>		<dt>Tristan FAURE, Atos</dt>		<dd>			He is an Eclipse committer on <a				href="http://www.eclipse.org/papyrus/">MDT Papyrus</a> project and			more generally on <a href='http://www.topcased.org'>TOPCASED</a>			components where he has made significant contributions over the last			years.		</dd>		<dt>Anne HAUGOMMARD, Atos</dt>		<dd>She is commiter on several TOPCASED components and is the			main contributor for Gendoc.</dd>		<dt>Aicha BOUDJELAL, Atos</dt>		<dd>She works on TOPCASED components and has provided significant			contributions to the existing code base of Gendoc.</dd>		<dt>Mathieu VELTEN, Atos</dt>		<dd>			He is an Eclipse committer on <a				href="http://www.eclipse.org/papyrus/">MDT Papyrus</a> and works on			TOPCASED.		</dd>	</dl>	<p>We welcome additional committers and contributions.</p>	<!--	Describe any initial contributions of code that will be brought to the 	project. If there is no existing code, just remove this section.-->	<h2>Mentors</h2>	<!--	New Eclipse projects require a minimum of two mentors from the Architecture	Council. You need to identify two mentors before the project is created. The	proposal can be posted before this section is filled in (it's a little easier	to find a mentor when the proposal itself is public).-->	<p>The following Architecture Council members will mentor this		project:</p>	<ul>		<li>C&eacute;dric Brun (Obeo)</li>		<li>Jonas Helming</li>	</ul>	<h2>Interested Parties</h2>	<!--	Provide a list of individuals, organisations, companies, and other Eclipse	projects that are interested in this project. This list will provide some	insight into who your project's community will ultimately include. Where	possible, include affiliations. Do not include email addresses.-->	<p>The following individuals, organisations, companies and projects		have expressed interest in this project:</p>	<ul>		<li><a href='http://www.airbus.com'>Airbus</a></li>		<li><a href='http://www.cnes.fr'>CNES</a></li>		<li><a href='http://obeo.fr/'>Obeo</a></li>	</ul>	<h2>Project Scheduling</h2>	<!--	Describe, in rough terms, what the basic scheduling of the project will	be. You might, for example, include an indication of when an initial contribution	should be expected, when your first build will be ready, etc. Exact	dates are not required.-->	<ul>		<li>October 2013: code submission and IP review</li>		<li>November 2013: first builds on the Eclipse infrastructure.</li>	</ul>	<h2>Changes to this Document</h2>	<!--	List any changes that have occurred in the document here.	You only need to document changes that have occurred after the document	has been posted live for the community to view and comment.-->	<table>		<tr>			<th>Date</th>			<th>Change</th>		</tr>		<tr>			<td>20-August-2013</td>			<td>Document created</td>		</tr>		<tr>			<td>30-September-2013</td>			<td>Update description section</td>		</tr>		<tr>			<td>11-November-2013</td>			<td>Second mentor added</td>		</tr>	</table></body></html>