<!DOCTYPE html>
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<meta http-equiv="Content-language" content="en">
	<meta name="description" content="Graphical Editors for your DSL">

	<script src="https://code.jquery.com/jquery-1.11.2.min.js"></script>
	<script type="text/javascript" src="../js/functions.js"></script>
	<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.5.8/angular.min.js"></script>
	<script src="../angular/sirius.js"></script>

	<link rel="icon" type="image/png" href="../favicon.ico" />
	<title>Sirius - What's New in Sirius 4.1</title>
	<link type="text/css" rel="stylesheet" href="../css/bootstrap.min.css" />
	<link type="text/css" rel="stylesheet" href="../css/style.css" />
	<link href='https://fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'> 
	<link href='https://fonts.googleapis.com/css?family=Open+Sans+Condensed:300italic,700,300' rel='stylesheet' type='text/css'>
	<link rel="stylesheet" href="https://use.fontawesome.com/ef6567f233.css">
	
	<!-- 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 -->  
	
	<!-- Eclipse Foundation cookie consent: -->
	<link rel="stylesheet" type="text/css" href="//www.eclipse.org/eclipse.org-common/themes/solstice/public/stylesheets/vendor/cookieconsent/cookieconsent.min.css" />
	<script src="//www.eclipse.org/eclipse.org-common/themes/solstice/public/javascript/vendor/cookieconsent/default.min.js"></script>
</head>

<body ng-app="sirius" ng-controller="main" class="cloak">
<ng-include src="'../angular/blocks/header.html'"></ng-include>

	<div id="body_wrapper">
		<h1 class="page_title">What's New in Sirius 4.1</h1>

		<p>What is making Eclipse Sirius so unique? That’s its capability
			to easily create custom graphical modeling tools adapted to each
			specific need.</p>
		<p>With Sirius 4.1, custom Properties Views come out of the experimental box and get promoted as an official production-ready feature. 
		As usual, this new release also comes with several UX improvements on diagrams.</p>
		<br /> <br />

		<div class="section">
			<h2><a name="properties_view"></a>Properties Views</h2>
			<p>Arrived with Sirius 4.0 as an experimental feature, this integrated way to define your own properties views is now mature and 
			ready for an usage in production.</p>
			<p>First, we have improved the default properties views which are provided by Eclipse Sirius, even if you didn’t specify any custom view. 
			After tests on many different metamodels, this new version correctly supports the main cases, so that now you have nice properties 
			views for free on your existing modeling tools built with Sirius.</p>
			<p>Most of all, these default properties views can be inlined into the specification of your modeling tool, so that you can modify them.</p>
			<p>In addition, new features have been added for the customization.</p> 
			<p>The most notable one is the new Reference widget which allows the user to see the relations of an object in a pre-built list coming with five buttons to manage the elements (browse, new, delete, up and down).</p>

			<p>
				<img class="shadow" src="../images/whatsnew4_1/reference-properties-view.png" alt="Sirius - Properties View" border="0" />
			</p>

			<p>As you can see, now it is possible to hide the legacy tabs (the Default and Semantic tabs automatically 
			generated by EMF).</p>

		
		<div class="section">
			<h2>
				<a name="customization"></a>UX Improvements
			</h2>
			<p>Like each version of Sirius, 4.1 brings many graphical improvements that simplify the user’s experience.</p>

			<h3><b>Better recognize edge’s label</b></h3>
			<p>When the user selects an edge, the labels are automatically selected and a link is shown between them. 
			On large diagrams containing many elements, this new feature (available by selecting an option in the preferences) allows 
			the user to more easily identify which label corresponds to which link.</p>

			<p>
				<img class="shadow" src="../images/whatsnew4_1/edge-label.gif"
					alt="Sirius - Link between an edge and its labels" border="0" />
			</p>
			<p>&nbsp;</p>

			<h3><b>Quicker style application</b></h3>
			<p>The existing copy/paste layout option has been extended to allow the user to also paste the graphical style of the 
			selected objects.</p>

			<p>Now, with Sirius 4.1, after the user has copied the format of diagram elements, he can choose to paste only the layout 
			(size and position, as it was already possible with Sirius 4.0), to paste only the graphical style (font, color, …) or to paste both. 
			Note that this option only applies to the same semantic elements.
			</p>

			<p>
				<img class="shadow" src="../images/whatsnew4_1/copy-paste-format.gif"
					alt="Sirius - Copy/Paste graphical style" border="0" />
			</p>

			<p>&nbsp;</p>

			<h3><b>Easier border nodes alignment</b></h3>
			<p>The Snap to Shape option is now available also on border nodes. 
			It means that Sirius displays guide to the user to facilitate the alignment of border nodes relatively to each other.
			</p>

			<p>
				<img class="shadow" src="../images/whatsnew4_1/snap-to-shape.gif" alt="Sirius - Border nodes alignment"
					border="0" />
			</p>
			<p>&nbsp;</p>

			<h2><a name="properties_view"></a>Other changes</h2>
		
			<h3><b>Reducing versions conflicts</b></h3>
			<p>Before Sirius 4.1, some issues could occur when users were trying to load a modeling project into a modeling tool of 
			which version was older than the one used to create the model.</p>

			<p>Now this kind of operation is forbidden: users can only load modeling projects with a tool whose version is the same 
			or is more recent (in this case Sirius automatically performs a migration).</p>

			<h3><b>Ready-to-use service class</b></h3>
			<p>To facilitate the creation of new services, when you create a new Viewpoint Specification Project, 
			by default an empty service class is automatically created and pre-registered, ready to host your Java methods!</p>

			<p>
				<img class="shadow" src="../images/whatsnew4_1/default-service-class.png" alt="Sirius - Reducing versions conflicts"
					border="0" />
			</p>
		</div>
		<p>Just <a href="http://www.eclipse.org/sirius/download.html">download</a> this new version, try it right now and share your experience / give us your feedback 
		on <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=262" target="_blank">Eclipse Sirius Community Forum</a>!
		</p>
		<p>This is just an overview of the most visible changes. The full list is detailed here: 
		<a href="http://www.eclipse.org/sirius/doc/Release_Notes.html" title="New & Noteworthy">http://www.eclipse.org/sirius/doc/Release_Notes.html</a>.</p>
		<p>To see new and noteworthy features of previous version, read <a href="http://eclipse.org/sirius/whatsnew/whatsnew4.html" title="New & Noteworthy">What's new in Sirius 4.0</a>.</p>
		<br />
		</div>
	</div>
	<!-- Fin body_wrapper -->

	<div class="clear"></div>
	<ng-include src="'../angular/blocks/footer.html'"></ng-include>
	<ng-include src="'../angular/blocks/call2action.html'"></ng-include>
</body>
</html>