<br style="clear:both;height:1em;">
	<div id="leftcol">
		<div class="nav-logo">
			<a href="index.php"><img src="logo.png" style="margin-left:10px; width:155px"/></a>
		</div>
		<ul id="leftnav">
		<li class="partentry" >
		Documentation
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; "  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="01-Introduction.php">Introduction</a></div>
		<ul style="display: none;" id="subToc_01-Introduction.html">
		<li id="01-Introduction.html#Customizations.html" ><a href="01-Introduction.php#Customizations.php" >Customizations</a></li>
		<li id="01-Introduction.html#Customizations_TheEasyWay.html" ><a href="01-Introduction.php#Customizations_TheEasyWay.php" >the Easy way</a></li>
		<li id="01-Introduction.html#Customitations_TheHardWay.html" ><a href="01-Introduction.php#Customitations_TheHardWay.php" >the Hard way</a></li>
		</ul>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; "  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="02-GettingStarted.php">Getting Started</a></div>
		<ul style="display: none;" id="subToc_02-GettingStarted.html">
		<li id="02-GettingStarted.html#Installation.html" ><a href="02-GettingStarted.php#Installation.php" >Installation</a></li>
		<li id="02-GettingStarted.html#FirstExample.html" ><a href="02-GettingStarted.php#FirstExample.php" >First Example</a></li>
		<li id="02-GettingStarted.html#RCPMail.html" ><a href="02-GettingStarted.php#RCPMail.php" >RCP Mail Example</a></li>
		</ul>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; "  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="03-Components.php">Components</a></div>
		<ul style="display: none;" id="subToc_03-Components.html">
		<li id="03-Components.html#FormComponent.html" ><a href="03-Components.php#FormComponent.php" >Form Component</a></li>
		<li id="03-Components.html#TreeComponent.html" ><a href="03-Components.php#TreeComponent.php" >Tree Component</a></li>
		<li id="03-Components.html#TreeFormComponent.html" ><a href="03-Components.php#TreeFormComponent.php" >Tree Form Component</a></li>
		<li id="03-Components.html#TableComponent.html" ><a href="03-Components.php#TableComponent.php" >Table Component</a></li>
		</ul>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; "  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="04-Customization.php">Customization</a></div>
		<ul style="display: none;" id="subToc_04-Customization.html">
		<li id="04-Customization.html#ResourceManagers.html" ><a href="04-Customization.php#ResourceManagers.php" >Managing Resources</a></li>
		<li id="04-Customization.html#Providers.html" ><a href="04-Customization.php#Providers.php" >Providers</a></li>
		<li id="04-Customization.html#SelectionAndMenu.html" ><a href="04-Customization.php#SelectionAndMenu.php" >Selection And Menu</a></li>
		<li id="04-Customization.html#Builders.html" ><a href="04-Customization.php#Builders.php" >Builders</a></li>
		<li id="04-Customization.html#Factories.html" ><a href="04-Customization.php#Factories.php" >Factories</a></li>
		<li id="04-Customization.html#Viewers.html" ><a href="04-Customization.php#Viewers.php" >Viewers</a></li>
		</ul>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; "  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="05-DSL.php">EMF Parsley DSL</a></div>
		<ul style="display: none;" id="subToc_05-DSL.html">
		<li id="05-DSL.html#xbase.html" ><a href="05-DSL.php#xbase.php" >Xbase features</a></li>
		</ul>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; display:none"  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="06-AdvancedComponents.php">Advanced Components</a></div>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; "  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="07-Eclipse4.php">Eclipse 4</a></div>
		<ul style="display: none;" id="subToc_07-Eclipse4.html">
		<li id="07-Eclipse4.html#GetFirstExample.html" ><a href="07-Eclipse4.php#GetFirstExample.php" >First Example Setup</a></li>
		<li id="07-Eclipse4.html#PrepareForEclipse4Application.html" ><a href="07-Eclipse4.php#PrepareForEclipse4Application.php" >Preparing for a pure Eclipse 4 Application</a></li>
		<li id="07-Eclipse4.html#CreateEclipse4Application.html" ><a href="07-Eclipse4.php#CreateEclipse4Application.php" >Create an Eclipse 4 Application</a></li>
		<li id="07-Eclipse4.html#Eclipse4ApplicationAndEMFParsley.html" ><a href="07-Eclipse4.php#Eclipse4ApplicationAndEMFParsley.php" >Using an EMF Parsley TreeComposite into an Eclipse 4 Part</a></li>
		<li id="07-Eclipse4.html#Eclipse4Save.html" ><a href="07-Eclipse4.php#Eclipse4Save.php" >Adding the dirty state and Save command</a></li>
		</ul>
		</li>
		<li class="partentry" >
		Appendix
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; display:none"  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="GettingSources.php">Getting Sources</a></div>
		</li>
		<li class="separator"><div class="separator">
		<img src="triangle.gif" style="height:12px; margin-right: 2px; display:none"  /><img src="triangle-90.gif" style="display:none; margin-right: 2px" height="12px" />
		<a href="Downloads.php">EMF Parsley - Downloads</a></div>
		</li>
		</ul>
	</div>
	<div id="midcolumn">
		<a name="Introduction" ></a>
		<h1>Introduction</h1>
				<div class="toc">
				  <ul>
				    <li><a href="01-Introduction.php#Customizations.php" >Customizations</a></li>
				    <li><a href="01-Introduction.php#Customizations_TheEasyWay.php" >the Easy way</a></li>
				    <li><a href="01-Introduction.php#Customitations_TheHardWay.php" >the Hard way</a></li>
				  </ul>
				</div>
				
		<p>
		Emf Parsley is a lightweight framework that allows easy and quick development
		of EMF-based Applications. It can be configured to use all kind of EMF persistence 
		implementations (XMI, Teneo, CDO).
		</p>
		<p>
		It aims at providing a set of Components like Trees, Tables and Detail Forms 
		that manage the model with the introspective EMF capabilities. 
		Using these components you can easily build forms, viewer or editors. 
		The framework provides basic UI implementations which are customizable 
		with Injection mechanism (based on <a href="http://code.google.com/p/google-guice" >Google Guice</a>).
		</p>
		<a name="Customizations" ></a>
		<span style="float:left; border-top: 1px dotted #d4d4dd; margin-left: 0; margin-top: 5px;
			padding: 5px 0;
			padding-top: 5px;"></span><a style="float: right" href="#">Top</a>
			<br style="clear:both"></br>
			<h1>Customizations</h1>
			<p>
			Basically <em>Emf Parsley</em> provides some built-in components that can be customized in several way.
			There are 2 ways you can do it: the easy one and the hard one!
			</p>
		<a name="Customizations_TheEasyWay" ></a>
		<span style="float:left; border-top: 1px dotted #d4d4dd; margin-left: 0; margin-top: 5px;
			padding: 5px 0;
			padding-top: 5px;"></span><a style="float: right" href="#">Top</a>
			<br style="clear:both"></br>
			<h1>the Easy way</h1>
			<p>
			The framework provides a DSL that allows to customize the most relevant behaviors.
			Currently the following are permitted:
			<ul>
			  <li>Content Provider</li>
			  <li>Label Provider</li>
			  <li>Guice Bindings</li>
			  <li>others..</li>
			</ul>
			</p>
			<p>
			You can use the DSL by creating a new project with the wizard &quot;Create a new project&quot; -&gt; &quot;EMF Parsley DSL Based project&quot;
			</p>
			<p>
			<div class="image" >
			<a class="gallery" rel="prettyPhoto[all]" title="" href="images/01-new-project-dsl-wizard.png">
				<img src="images/01-new-project-dsl-wizard.png" 
					width="600px"
				/>
			</a>
			<div class="caption">
			</div>
			</div>
			</p>
			<p>
			Clicking the &quot;Finish&quot; button the wizard will open directly the dsl editor. You can use the content assistant
			to discover all features.
			</p>
			<p>
			<div class="image" >
			<a class="gallery" rel="prettyPhoto[all]" title="" href="images/01-dsl-content-assistant.png">
				<img src="images/01-dsl-content-assistant.png" 
					width="600px"
				/>
			</a>
			<div class="caption">
			</div>
			</div>
			</p>
		<a name="Customitations_TheHardWay" ></a>
		<span style="float:left; border-top: 1px dotted #d4d4dd; margin-left: 0; margin-top: 5px;
			padding: 5px 0;
			padding-top: 5px;"></span><a style="float: right" href="#">Top</a>
			<br style="clear:both"></br>
			<h1>the Hard way</h1>
			<p>
			This way is
			If you need a deeper degree of customizations, you can use the injection mechanism based on Google Guice.
			The framework has been designed for being completly customized in every detail. All you need to do is provide a custom
			implementation for a class that implements a specific aspect; then you need to write the corresponding
			<em>bind</em> method to tell the dependency injection mechanism to use your own custom class.
			You can use the Java editor content assist to discover all bindings. 
			</p>
			<p>
			<div class="image" >
			<a class="gallery" rel="prettyPhoto[all]" title="" href="images/01-guice-module-content-assistant.png">
				<img src="images/01-guice-module-content-assistant.png" 
					width="600px"
				/>
			</a>
			<div class="caption">
			</div>
			</div>
			</p>
		<div id="disqus_thread"></div>
		<script type="text/javascript" src="documentationRoot.js"></script>
		<script type="text/javascript">
		    /* * * CONFIGURATION VARIABLES: EDIT BEFORE PASTING INTO YOUR WEBPAGE * * */
		    var disqus_shortname = 'xtext'; // required: replace example with your forum shortname
		
		    // The following are highly recommended additional parameters. Remove the slashes in front to use.
		    var disqus_identifier = 'Introduction';
		    var disqus_url = documentationRoot+'01-Introduction.php';
		
		    /* * * DON'T EDIT BELOW THIS LINE * * */
		    (function() {
		        var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
		        dsq.src = 'http://' + disqus_shortname + '.disqus.com/embed.js';
		        (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
		    })();
		</script>
 		<noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
	</div>
	<br style="clear:both;height:1em;">
