<!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 - Adopters</title>
<meta name="description" content="Find the answers to your questions about Capella, an Open Source MBSE tool that implements the Arcadia method.">
<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 -->


<!-- shuffle function -->
<script>
function shuffle(array) {
  var currentIndex = array.length, temporaryValue, randomIndex;

  // While there remain elements to shuffle...
  while (0 !== currentIndex) {

    // Pick a remaining element...
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex -= 1;

    // And swap it with the current element.
    temporaryValue = array[currentIndex];
    array[currentIndex] = array[randomIndex];
    array[randomIndex] = temporaryValue;
  }

  return array;
}
</script>
<!-- End shuffle function -->


<!-- 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>
<!-- bootstrap js -->
<script src="js/bootstrap.min.js"></script>
<!-- wow js -->
<script src="js/wow.min.js"></script>
<!-- template main js -->
<script 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 adopters">
		<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">Adopters</h1>
						</section>
						<h2 class="wow fadeInUp animated" data-wow-delay=".6s">
								Eclipse Capella is a MBSE solution adopted worldwide in various industrial domains.<br>Discover some of the many organizations using Capella.
						</h2>
					</div>
				</div>
			</div>
		</div>
	</section>
	<!--/#intro_banner-->

	<section id="adopters" class="">
		<script type="text/javascript">
  			jQuery.getJSON('json/adopters.json', function(data) {

  			var output = " " ;
	        	var items = " ";

	        let adopters=shuffle(data.adopters);

	        for (var i in adopters) {
	        	var item = " ";

				item ="<img src='" + adopters[i].logoSrc + "' alt='Capella Adopters - " + adopters[i].company +"' title='" + adopters[i].company + "' />";

				link = adopters[i].link;

				if (link!=null && link!="") {
					items += "<li><a href='" + link + "' target='_blank'>" + item + "</a></li>";
				}
				else {
					items += "<li>" + item + "</li>";
				}
			}

	        output += "<div class='container'><div class='row'><ul class='list-inline'>" + items + "</ul></div></div>";


	        document.getElementById("adopters").innerHTML=output;
 		 });
   		</script>
	</section>

	<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_adopters.html'"></ng-include>

	<!--
        ==================================================
        Footer Section
        ================================================== -->
	<ng-include src="'angular/blocks/footer.html'"></ng-include>
	<script async src="js/googleAnalytics.js" ></script>
</body>
</html>