<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" 
	   "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<meta http-equiv="Content-language" content="en">
	<meta name="description" content="EMF Compare provides comparison and merge facility for any kind of EMF Model">
	 
	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
	<script type="text/javascript" src="js/googleAnalytics.js"></script>
	<script type="text/javascript" src="js/functions.js"></script>
	
	<link rel="icon" type="image/png" href="favicon.ico" />
	<title>EMF Compare - Compare and Merge Your EMF Models</title>
	<link type="text/css" rel="stylesheet" href="css/style.css" />		
</head>
	
<body>

<div id="header_wrapper">
	<div id="logo">
		<a href="index.html"><img alt="logo" src="images/logos/logo.png" /></a>
	</div>
	
	<div id="menu_wrapper">
		<ul id="nav">
			<li><a href="overview.html">Overview</a></li>
			<li><a href="download.html">Download</a></li>
			<li><a href="http://www.eclipse.org/emf/compare/documentation/latest/user/user-guide.html">Get Started</a></li>
			<li class="current_menu_item last_item"><a href="community.html">Community</a></li>
		</ul>
	</div>	<!-- Fin menu_wrapper -->
</div>	<!-- Fin header_wrapper -->

<div id="body_wrapper">	
	<h1 class="page_title">Community</h1>
	
	<div class="community_links">
		<h1>Learn</h1>
		<div class="community_item">
			<h2><a href="http://www.eclipse.org/emf/compare/documentation/latest/user/user-guide.html">Get Started</a></h2>
			<a href="http://www.eclipse.org/emf/compare/documentation/latest/user/user-guide.html"><span class="community_icons" id="start"></span></a>
			<p>Take your first step with EMF Compare</p>
		</div>
		<div class="community_item">
			<h2><a href="http://www.eclipse.org/emf/compare/documentation/latest/">Documentation</a></h2>
			<a href="http://www.eclipse.org/emf/compare/documentation/latest/"><span class="community_icons" id="doc"></span></a>
			<p>Complete user guide and developer manual</p>
		</div>
		<div class="community_item last_item">
			<h2><a href="http://wiki.eclipse.org/EMF_Compare">Wiki</a></h2>
			<a href="http://wiki.eclipse.org/EMF_Compare"><span class="community_icons" id="wiki"></span></a>
			<p>Additional resources to follow the activity of the project</p>
		</div>
	</div> <!-- Fin community_links -->		
	
	<div class="clear"></div>
	
	<div class="community_links">
		<h1>Ask</h1>
		<div class="community_item">
			<h2><a href="http://www.eclipse.org/forums/index.php/f/164/">Forum</a></h2>
			<a href="http://www.eclipse.org/forums/index.php/f/164/"><span class="community_icons" id="forum"></span></a>
			<p>Find relevant posts/answers. No solution yet to your concern? Come and ask your question</p>
		</div>
		<div class="community_item">
			<h2><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&classification=Modeling&product=EMFCompare&query_format=advanced">Bug Tracker</a></h2>
			<a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&classification=Modeling&product=EMFCompare&query_format=advanced"><span class="community_icons" id="bug"></span></a>
			<p>Review and create bugzilla entry for bug reporting and enhancement</p>
		</div>
		<div class="community_item last_item">
			<h2><a href="http://www.eclipse.org/emf/compare/support/">Professional Support</a></h2>
			<a href="http://www.eclipse.org/emf/compare/support/"><span class="community_icons" id="support"></span></a>
			<p>Obeo, leader of EMF Compare, provides professional support services to help you with EMF Compare: training, custom development & expertise.</p>
		</div>
	</div> <!-- Fin community_links -->	
	
	<div class="clear"></div>
	
	<div class="community_links">
		<h1>Engage</h1>
		<div class="community_item">
			<h2><a href="http://projects.eclipse.org/projects/modeling.emf.compare">Project Page</a></h2>
			<a href="http://projects.eclipse.org/projects/modeling.emf.compare"><span class="community_icons" id="project"></span></a>
			<p>Participate in the project. Contribute patches. Become a committer.</p>
		</div>
		<div class="community_item">
			<h2><a href="http://git.eclipse.org/c/emfcompare/org.eclipse.emf.compare.git/">Source code</a></h2>
			<a href="http://git.eclipse.org/c/emfcompare/org.eclipse.emf.compare.git/"><span class="community_icons" id="code"></span></a>
			<p>Get the code from Git</p>
		</div>
		<div class="community_item last_item">
			<h2><a href="https://dev.eclipse.org/mailman/listinfo/emf-dev">Developer Mailing List</a></h2>
			<a href="https://dev.eclipse.org/mailman/listinfo/emf-dev"><span class="community_icons" id="mailing"></span></a>
			<p>The core developers mailing list (for committers, contributors and pretty much anyone that is interested in the mechanics of EMF Compare)</p>
		</div>
	</div> <!-- Fin community_links -->	

	<div class="clear"></div>
</div> <!-- Fin body_wrapper -->	

<div class="clear"></div>

<div id="footer_wrapper">
	<div id="footer_content">
		<div class="column">
			<div class="columntitle">
				<h3>Eclipse Links</h3>
			</div>
			<ul>
				<li><a href="http://www.eclipse.org/legal/privacy.php"> Privacy Policy</a></li>
				<li><a href="http://eclipse.org/"> Eclipse</a></li>
				<li><a href="http://www.eclipse.org/legal/termsofuse.php"> Terms of Use</a></li>
				<li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
				<li><a href="http://www.eclipse.org/legal/">Legal</a></li>
				<li><a href="http://www.eclipse.org/org/foundation/contact.php"> Contact Us</a></li>
			</ul>
		</div>
		
		<div class="column">
			<div class="columntitle">
				<h3>Community</h3>
			</div>
			<ul>
				<li><a href="http://www.eclipse.org/emf/compare/documentation/latest/user/user-guide.html" target="_blank" >Get Started</a></li>
				<li><a href="http://www.eclipse.org/emf/compare/documentation/latest/" target="_blank">Documentation</a></li>
				<li><a href="http://wiki.eclipse.org/EMF_Compare" target="_blank">Wiki</a></li>
				<li><a href="http://www.eclipse.org/forums/index.php/f/164/" target="_blank">Forum</a></li>
				<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&classification=Modeling&product=EMFCompare&query_format=advanced" target="_blank">Bug Tracker</a></li>
				<li><a href="http://www.eclipse.org/emf/compare/support/" target="_blank">Professional Support</a></li>
				<li><a href="https://dev.eclipse.org/mailman/listinfo/emf-dev" target="_blank">Developer Mailing List</a></li>
				<li><a href="http://git.eclipse.org/c/emfcompare/org.eclipse.emf.compare.git/" target="_blank">Source Code</a></li>
			</ul>
		</div>
		
		<div class="column">
			<a href="http://www.eclipse.org/"><img src="images/logos/eclipse.png" alt="Eclipse logo"></a>
			<span id="copyright">Copyright © <span id="year">YEAR</span> The Eclipse Foundation. All Rights Reserved.</span>
		</div>
	</div>
</div>	

</body>
</html>
