<!-- 
	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>e(fx)clipse - JavaFX tooling and runtime for Eclipse</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>The e(fx)clipse project is a proposed open source project under the <a
	href="http://www.eclipse.org/projects/project.php?id=technology">Technology</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>

<p>
JavaFX is the new UI and graphics toolkit developed by Oracle and the official successor of Swing. Since Java7 Update 7 it has been part of the JRE/JDK distributions and the entire source code is expected to be open sourced by February 2013 as part of the OpenJDK.
</p>

<p>
JavaFX is designed to run not only on desktop systems but also on low-cost hardware like the Rasperry PI and Beagleboard and plays an important role in Oracle "Internet of things" vision.
</p>

<p>
From a developer perspective, developing JavaFX applications involves the following technologies:
<ul>
<li>Java for the logic</li>
<li>CSS for the styling (optional)</li>
<li>FXML for the UI (optional)</li>
</ul>
</p>

<h2>Scope</h2>

<h3>Tooling</h3>

<p>Developers intending to develop a JavaFX application will most likely deal with three technologies: Java, CSS and FXML. </p>

<p>To simplify development, the project provides:
<ul>
<li>Java: wizards and templates for projects</li>
<li>CSS: A specialized editor that understands the JavaFX specific CSS properties</li>
<li>FXML: A specialized XML editor providing autocompletion based on information gathered from JDT</li>
</ul>
</p>

<p>
To help developers to build and deploy their applications, JavaFX provides specialized ant-tasks that aid the developer when packaging an application as an installable unit (msi, rpm, dmg). e(fx)clipse tooling provides a specialized editor to help the developer configure and drive the build process.
</p>

<p>
For developers who do not want to define their UI in XML, the project provides an alternative format named FXGraph that looks similar to JSON. More information about the format can be found at <a href="http://efxclipse.org/trac/wiki/FXGraph">http://efxclipse.org/trac/wiki/FXGraph</a> 
</p>

<p>
Developers who are developing JavaFX applications on top of OSGi will most likely use PDE as their development tool. Because JavaFX is not on the bootclasspath, PDE needs to be tweaked in order to allow a decent development experience. Besides the low-level integration into PDE, the project also provides wizards to easily bootstrap applications.
</p>

<h3>Runtime</h3>

<h4>Equinox</h4>

<p>JavaFX is not on the bootclasspath and not JSRed until Java9. So Equinox will not know about it out of the box. e(fx)clipse provides an extension for equinox to fill this gap.</p>

<p>Beside this low level support, the project provides all sorts of utilities, for example easened integration of JavaFX components when run inside OSGi.</p>

<h4>Eclipse Databinding</h4>

<p>Eclipse Databinding is a technology to bind domain objects to UI-Controls. JavaFX has a custom property and binding system. e(fx)clipse provides adapters for the JavaFX property system so that default Eclipse databinding can be used.</p>

<h4>EMF</h4>

<p>Developers using EMF to model their domain models often use code generated out of their Ecore definition. This allows them to setup structured controls like List, Table and Tree with very few lines of code. The project provides integration for EMF edit so that developers get the same benefits they do when using EMF in conjunction with SWT.</p>

<h4>e4 &amp; Eclipse 4 Application Platform</h4>

<p>The Eclipse 4 Application Platform has been designed from day one to be widget toolkit neutral. The e(fx)clipse project provides so called JavaFX-renderers, allowing developers to leverage all parts of the Eclipse 4 Application Platform (Dependency Injection, Application Model, Command-Framework, .....) without using SWT.</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>
e(fx)clipse is a project currently hosted at github (<a href="https://github.com/tomsontom/e-fx-clipse">https://github.com/tomsontom/e-fx-clipse</a>), providing tooling and runtime components that help developers to create JavaFX applications.
</p>

<p>
Since its creation in July 2011, the project has seen sixteen releases and has gained an active user base that has started adopting different parts of the project. The project maintains a public bug-tracker (<a href="http://efxclipse.org/trac">http://efxclipse.org/trac</a>) and a discussion forum (<a href="https://groups.google.com/forum/#!forum/efxclipse">https://groups.google.com/forum/#!forum/efxclipse</a>). 
</p>


<h2>Why Eclipse?</h2> 

<p>
Like outlined in the initial paragraphs JavaFX is <b>THE</b> next UI-Toolkit for Java and
it is expected that many people will develop applications with it in the near future.
</p>
<p>
To stay relevant in future the Eclipse IDE has to provide top quality support for JavaFX.
</p>

<p>
The project provides runtime components who can be adopted by other Eclipse.org projects (like Riena, Scout)
and because the Eclipse Process ensures IP code the adoption in commercial products is
going to be much easier.
</p>

<h2>Initial Contribution</h2>

<p>The current code is hosted at github and provides an implementation of all mentionned
editors, wizards and runtime items.</p>

<p>It is structured in OSGi-Bundles and split in 3 categories:</p>
<ul>
<li>tooling bundles: starting with at.bestsolution.efxclipse.tooling</li>
<li>runtime bundles: starting with at.bestsolution.efxclipse.runtime</li>
<li>sample bundles: starting with at.bestsolution.efxclipse.runtime.demo and at.bestsolution.efxclipse.runtime.examples</li>
</ul>

<!-- 
	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.
 -->
 
<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?
 -->
 
 There are some media files (images, videos) who are released under LGPL and need
 to be removed and replaced by EPL compatible ones.
 
<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 individuals are proposed as initial committers to the project:</p>

<dl>
	<dt>Tom Schindl, BestSolution.at Systemhaus GmbH</dt>
	<dd>Tom is the project lead and main architect</dd>
	<dt>Chrisoph Caks, BestSolution.at Systemhaus GmbH</dt>
	<dd>Christoph is a software developer at BestSolution.at. He's the main author of the CSS-Editor infrastructure and will continue to maintain it.</dd>
	<dt>Martin Bl&uuml;hweis, BestSolution.at Systemhaus GmbH</dt>
	<dd>Martin is a software developer at BestSolution.at and implemented e.g. the build-Editor.</dd>
	<dt>Torsten Sommer, TESIS DYNAware</dt>
	<dd>Torsten is a software developer at TESIS DYNAware and implemented the EMF-Edit support. He's responsible for maintaining and extending it</dd>
</dl>


<!-- 
	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>Tom Schindl</li>
	<li>Chris Aniszczyk</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>BestSolution.at GmbH - Tom Schindl</li>
	<li>TESIS DYNAware - Uwe Sander</li>
	<li>XETICS GmbH - Ralf Muckenhirn</li>
	<li>BSI AG / Scout - Matthias Zimmermann</li>
	<li>compeople / Riena - Christian Campo</li>
	<li>Software Competence Center Hagenberg GmbH - Mario Winterer</li>
	<li>Sopot Cela</li>
	<li>Jan K&ouml;hnlein</li>
	<li>NatTable - Dirk Fauth</li>
	<li>Miranda Technologies - Ronald Timbol</li>
	<li>Cayros Software - Juan Felipe Caro</li>
	<li>Siemens AG - Kai T&ouml;dter</li>
	<li>Oracle - Donald Smith</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>Creation Review - Febuary 2013</li>
<li>0.9.0 - Initial release at Eclipse.org (Q1/2 2013)</li>
<li>0.9.1 - Service release with Java7 and Java8 support (Q2 - together with Kepler)</li>
<li>0.9.2 - Service release (Q3 - together with Java8)</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>22-01-2013</td>
		<td>Document created</td>
	</tr>
	<tr>
		<td>29-01-2013</td>
		<td>Added more interested parties</td>
	</tr>
</table>
</body>
</html>
