<!DOCTYPE html>
<html class="no-js">
<head>
<!-- Basic Page Needs
        ================================================== -->
<meta charset="utf-8">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link rel="icon" type="image/png" href="images/favicon.ico">
<title>Capella MBSE Tool - Add-Ons</title>
<meta name="description" content="Beyond Capella, the ecosystem offers extensions to unleash the power of your MBSE workbench.">
<meta name="keywords" content="">
<meta name="author" content="">
<!-- Mobile Specific Metas
        ================================================== -->
<meta name="format-detection" content="telephone=no">
<meta name="viewport" content="width=device-width, initial-scale=1">

<!-- Template CSS Files
        ================================================== -->
<!-- Twitter Bootstrs CSS -->
<link rel="stylesheet" href="css/bootstrap.min.css">
<!-- animate css -->
<link rel="stylesheet" href="css/animate.css">
<!-- template main css file -->
<link rel="stylesheet" href="css/main.css">
<!-- responsive css -->
<link rel="stylesheet" href="css/responsive.css">
<link rel="stylesheet" href="css/latofonts.css">

<script src="https://use.fontawesome.com/b51f77a16a.js"></script>

<!-- Cookie content -->
<link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
<script async src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>

<!-- Eclipse Foundation Google Tag Manager -->
<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,'script','dataLayer','GTM-5WLCZXC');</script>
<!-- End Google Tag Manager -->

<!-- Template Javascript Files
        ================================================== -->
<!-- Angular -->
<base href="/capella/">
<script src="js/angular-1.7.8.min.js"></script>
<script src="angular/capella.js"></script>

<!-- modernizr js -->
<script src="js/vendor/modernizr-2.6.2.min.js"></script>
<!-- jquery -->
<script src="js/jquery-3.4.1.min.js"></script>
<script src="js/popper-1.14.3.min.js"></script>
<!-- bootstrap js -->
<script src="js/bootstrap.min.js"></script>
<!-- wow js -->
<script src="js/wow.min.js"></script>
<!-- template main js -->
<script async src="js/main.js"></script>

</head>
<body ng-app="capella" data-deferred-cloak>
	<!--
     ==================================================
     Header Section
     ================================================== -->
	<ng-include src="'angular/blocks/header.html'"></ng-include>
	<!--
    ==================================================
    Intro Section
    ================================================== -->
	<section class="hero-area addons">
		<div class="container">
			<div class="row">
				<div class="col-md-12 text-center">
					<div class="block wow fadeInUp" data-wow-delay=".3s">

						<section class="cd-intro">
							<h1 class="wow fadeInUp animated" data-wow-delay=".4s">Add-Ons</h1>
						</section>
						<!-- cd-intro -->
						<h2 class="wow fadeInUp animated" data-wow-delay=".6s">
							Beyond Eclipse Capella, the ecosystem offers extensions <br>to
							unleash the power of your MBSE workbench
						</h2>
					</div>
				</div>
			</div>
		</div>
	</section>
	<!--/#intro_banner-->

	<!--
        ==================================================
        Secure your industrial Capella deployment
        ================================================== -->
		<section id="services" class="">
				<div class="container">
				
					<div class="row">
						<p><i>To install Capella extensions have a look to the <a href="https://github.com/eclipse/capella/blob/master/doc/plugins/org.polarsys.capella.ui.doc/html/Installation%20Guide/How%20to%20install%20Capella%20and%20Addons.mediawiki#Configuration_and_Extensibility" target="_blank">installation procedure</a></i></p>
					</div>
					
					<div class="row">
						<div id="accordion-opensource-addons" class="accordion dropdown_content">
						</div>
					</div>
					
					<div class="row">
						<div id="accordion-commercial-addons" class="accordion dropdown_content">
						</div>
					</div>
					
					<div class="row">
						<div id="accordion-labs-addons"><h1>Labs add-ons</h1></div>
						It is the place where Capella users, as well as tool providers, can collaborate and create synergies to develop Capella add-ons
						<a class="btn btn-default" href="https://labs4capella.github.io">Discover Labs for Capella&nbsp;<i class="fa fa-external-link"></i></a>
						<br/><br/>
					</div>
					
					<div class="row">
						<div id="accordion-sample-addons" class="accordion dropdown_content">
						</div>
					</div>
					
					<div class="row">
						<p class="underline"><b><u>Compatibility and integration</u></b></p>
						<p><i>Each author is responsible for the compatibility of his add-ons with different versions of Capella. See the Add-ons <a href="https://wiki.eclipse.org/Capella/Roadmap#Add-ons" target="_blank">releases and compatibility matrix</a></i>
						<br><i>Additional integration may be needed between two add-ons provided by different authors.</i></p>
					</div>
					
				</div>
		</section>
		
		<script>

				   $.getJSON('json/downloads.json', function(data) {
					  let eplAddons = data.addons.filter(function(a) { return a.licence == 'EPL' && !a.isSample }); //Open-source add-ons
					  let commercialAddons = data.addons.filter(function(a) { return a.licence == 'Commercial' }); //Commercial add-ons
					  let sampleAddons = data.addons.filter(function(a) { return a.isSample });

					  if (eplAddons.length != 0) {
						addTitleToDiv("accordion-opensource-addons", "Open-Source Add-ons");
						for (addon in eplAddons) {
							addAddonSection(data, eplAddons[addon], "accordion-opensource-addons");
						}
					  }

					  if (commercialAddons.length != 0) {
						addTitleToDiv("accordion-commercial-addons", "Commercial Add-ons");
						for (addon in commercialAddons) {
							addAddonSection(data, commercialAddons[addon], "accordion-commercial-addons");
						}
					  }
					  
					  if (sampleAddons.length != 0) {
						addTitleToDiv("accordion-sample-addons", "Sample Add-ons", "Add-ons that show how to start developing add-ons for Capella using Capella Studio");
						
						for (addon in sampleAddons) {
							addAddonSection(data, sampleAddons[addon], "accordion-sample-addons");
						}
					  }
				   });

				  function addTitleToDiv(divId, title, description) {
					let desc = description == undefined ? "": description;
					document.getElementById(divId).innerHTML += "<div><h1>" + title + "</h1>" + desc + "</div>";
				  }

				  function addAddonSection(data, addon, divId) {
						let keys = Object.keys(addon.download);
						 let fragment = addon.fragment != undefined ? addon.fragment : addon.key;
						 let links = keys.map(function(k) {
							let icon = data.lang[k].icon ? '<i class="pl-2 {0}" aria-hidden="true"></i>'.format(data.lang[k].icon) : "";
							return '<a href="{0}" target="{1}" onClick="ga("send", "event", "Capella", "{2}", "{3}");">{4}{5}</a>'.format(addon.download[k], data.lang[k].target, data.versionBranch, addon.key, data.lang[k].text, icon);
						 }).join(" - ");
						 let header = [];
						 if (addon.contact) {
							header.push("Contact: "+addon.contact);
						 }
						 if (addon.licence) {
							header.push("License: "+addon.licence);
						 }
						 if (addon.tags) {
						 	let tags='';
						 	for (tag in addon.tags) {
						 		tags+=' <button class="tag">'+addon.tags[tag]+'</button>';
							}
							header.push(tags);
						 }
						 header=header.join(" - ");

						 let compatible = addon.compatibleWithCurrentVersion === false ? '<button role="button" class="fa fa-exclamation-triangle btn-link btn-xs alert-compatibility" data-toggle="tooltip" data-placement="bottom" title="{0}" ></button>'.format(data.lang.compatibility.text) : "";
						 let addonName = addon.isViewpoint ? addon.name + " Viewpoint" : addon.name;

						 let dropdown = '<div class="accordion-heading"><a class="accordion-toggle collapsed" data-toggle="collapse" data-parent="#accordion2" href="#{0}"><h3>{1}</h3><span class="fa fa-caret-down txt_yellow">&nbsp;</span><span class="descr txt_lightest_grey">{2}</span></a></div>'.format(fragment, addonName, header);

						 let content = '<div id="{0}" class="accordion-body collapse" style="height: 0px;"><div class="accordion-inner">{1}<p>{2}{3}</p></div></div>'.format(fragment, addon.description, compatible, links);
						 let result = '<div class="accordion-group">{0}{1}</div>'.format(dropdown, content);

						 document.getElementById(divId).innerHTML += result;

					  $('[data-toggle="popover"]').popover( { html: true, container: 'body' });
					  $('[data-toggle="tooltip"]').tooltip();
					}
			  </script>

			  
			  
	<!-- #services -->

	<div id="back-to-top" data-spy="affix" data-offset-top="100"
		class="back-to-top hidden-xs hidden-sm affix-top">
		<button class="btn btn-default" title="Back to Top">
			<i class="fa fa-caret-up"></i>
		</button>
	</div>
	<script type="text/javascript">
	// Back to top
		jQuery('#back-to-top').on('click', function() {
			jQuery("html, body").animate({
				scrollTop : 0
			}, 500);
			return false;
		});
	</script>

	<!--
        ==================================================
        Call To Action Section Start
        ================================================== -->
        		<ng-include src="'angular/blocks/call2action_services.html'"></ng-include>



	<!--
        ==================================================
        Footer Section
        ================================================== -->
	<ng-include src="'angular/blocks/footer.html'"></ng-include>
	<script async src="js/googleAnalytics.js" ></script>
</body>
</html>