<div id="bigbuttons">
<h3>Primary Links</h3>
<ul>
	<li><a id="buttonDownload" href="download.php" title="Download">Eclipse
	Distribution, Update Site, Dropins</a></li>
	<li><a id="buttonDocumentation" href="documentation"
		title="Documentation">Tutorials, Examples, Videos, Reference
	Documentation</a></li>
	<li><a id="buttonSupport" href="support" title="Download">Bug
	Tracker, Newsgroup, Professional Support</a></li>
	<li><a id="buttonInvolved" href="developers"
		title="Getting Involved">Git, Workspace Setup, Wiki, Committers</a></li>
</ul>
</div>

<div id="midcolumn">
<h3>Graphiti - a Graphical Tooling Infrastructure</h3>
<div id="introText">

<p>Eclipse provides a modeling infrastructure evolving around the
Eclipse Modeling Framework (EMF) for which offering graphical
representations and editing possibilities is essential.</p>
<p>Graphiti is an Eclipse-based graphics framework that enables
rapid development of state-of-the-art diagram editors for domain models.
Graphiti can use EMF-based domain models very easily but can deal with
any Java-based objects on the domain side as well.</p>
<p>The objectives of the Graphiti project are the following:
<ul>
	<li>Provide an easy to use and well structured plain Java API for
	building graphical tools</li>
	<li>Provide documentation and tutorials for doing so</li>
	<li>Limit the dependencies of the framework to an absolute minimum
	to support RCP-like scenarios</li>
	<li>Provide optional components beyond the RCP use case to ease
	e.g. IDE integration</li>
	<li>Provide the ability to use any existing layout algorithms for
	auto layouting a diagram</li>
</ul>
</p>

</div>

<img src="images/Screenshot-CPL-PlanDrivenProcurement.png"
	alt="CPL Plan Driven Procurement" width="100%"> <!-- 
<div id="screencast"><object width="640" height="480">
	<param name="allowfullscreen" value="true" />
	<param name="allowscriptaccess" value="always" />
	<param name="movie"
		value="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" />
	<embed
		src="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1"
		type="application/x-shockwave-flash" allowfullscreen="true"
		allowscriptaccess="always" width="640" height="480"></embed></object></div>
--> <!-- 
<h3>...and yet powerful</h3>
 -->
<div id="feature_flatLearningCurve">

<h4>Flat learning curve</h4>
<p>Graphiti completely hides platform dependent technologies like
GEF and Draw2D at its API. The user deals with a plain Java API and
Graphiti specific objects. This simply hides all the nuts and bolts
underneath.</p>
</div>

<div id="feature_fastEasyDevelopment">
<h4>Fast and easy development of graphical editors for various
domain models</h4>
<p>First results in the form of running editors can be reached with
very low effort by using the provided default implementations and the
strong framework. In further steps the editor can be incrementally
refined and improved.</p>
</div>

<div id="feature_commonLookFeel">
<h4>Common look and feel with sensible defaults</h4>
<p>User interactions for Graphiti tools were designed in close
co-operation with usability specialists leading to a state-of-the-art
behavior of the tool right out of the box. In case the default behavior
is not suitable for the tool, it can be freely adapted to specific
needs.</p>
</div>

<div id="feature_differentPlatforms">
<h4>Option to support different platforms</h4>
<p>Diagrams are defined platform independently, enabling using a
different rendering engine (e.g. for a Flash Web Ui). Currently Graphiti
only supports Eclipse, but the framework itself is open for other
platforms as well. Nevertheless platform specifics (like color dialog,
font dialog, etc.) can be integrated.</p>
</div>

<div id="feature_accessibility">
<h4>Accessibility</h4>
<p>Graphiti enables its users to build accessible tools that allow
motion-impaired and vision-impaired people to use these tools. Graphiti
provides full keyboard access to all functionality, supports themes like
the high contrast mode and allows users to enlarge the visual
representation of diagrams.
</div>

<div id="feature_more">
<h4>and much more...</h4>
<br>
Read the <a href="/graphiti/documentation">documentation</a></br>
<br>
Join the discussion at the <a
	href="http://www.eclipse.org/forums/eclipse.graphiti">forum</a></br>
<br>
<a
	href="http://www.eclipse.org/projects/project_summary.php?projectid=modeling.graphiti">About
this project</a></br>
</div>

</div>

<div id="rightcolumn">
<div class="sideitem">
<h6>Incubation</h6>
<div align="center"><a
	href="http://www.eclipse.org/projects/what-is-incubation.php"><img
	align="center" src="http://www.eclipse.org/images/egg-incubation.png"
	border="0" alt="Incubation" /></a></div>
<p>Graphiti is in the <a
	href="http://www.eclipse.org/projects/dev_process/incubation-phase.php">Incubation
Phase</a>.</p>
</div>



<div id="headlines">
<h3>New and Noteworthy</h3>
<p>Graphiti 0.9.0 is released as part of the Eclipse Indigo release
train and available for download. See <a href="download.php">the
downloads section</a> for the locations.</p>
<p>The service release 0.8.2 of Graphiti is available within the
Indigo SR2 service release. See the <a href="download.php">downloads
section</a> for details.</p>
</div>

<div id="headlines">
<h3>Headlines on the web</h3>
<p><a
	href="http://jacekonthings.blogspot.de/2012/08/drawing-in-graphiti.html">Blog on creating a drawing tool with Graphiti by Jacek Pospychala</a></p>
<p><a
	href="http://www.ancitconsulting.com/tiki-index.php?page=Tutorials">Tutorials by ANCiT Consulting</a></p>
<p><a
	href="http://kthoms.wordpress.com/2011/05/30/spray-a-quick-way-to-create-graphiti/">Spray
- a quick way to create Graphiti</a></p>
<p><a href="http://twitter.com/dzonejames/status/22172988677">User
feedback on Twitter</a></p>
</div>

</div>