diff --git a/about.html b/about.html
index 64c0598..e8b834d 100644
--- a/about.html
+++ b/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/jenkins.build.config.xml b/jenkins.build.config.xml
index c4355da..1c32037 100644
--- a/jenkins.build.config.xml
+++ b/jenkins.build.config.xml
@@ -2,9 +2,11 @@
 <!--#======================================================================= -->
 <!--# Copyright (c) 2016 - Loetz GmbH&Co.KG                                    -->
 <!--# All rights reserved. This program and the accompanying materials 		 -->
-<!--# are made available under the terms of the Eclipse Public License v1.0  -->
+<!--# are made available under the terms of the Eclipse Public License 2.0   -->
 <!--# which accompanies this distribution, and is available at               -->
-<!--# http://www.eclipse.org/legal/epl-v10.html                              -->
+<!--# https://www.eclipse.org/legal/epl-2.0/                                 -->
+<!--#                                                                        -->
+<!--# SPDX-License-Identifier: EPL-2.0                                       -->
 <!--#                                                                        -->
 <!--# Contributors:                                                          -->
 <!--# Christophe Loetz (Loetz GmbH&Co.KG) - initial API and implementation                           -->
diff --git a/notice.html b/notice.html
index c3d34c3..008b801 100644
--- a/notice.html
+++ b/notice.html
@@ -7,101 +7,183 @@
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>April 9, 2014</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
-   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
-   repository (&quot;Repository&quot;) in software modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
-Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license (&quot;Feature Update License&quot;) during the
-installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager (&quot;Provisioning Technology&quot;) for the purpose of allowing users to install software, documentation, information and/or
-   other materials (collectively &quot;Installable Software&quot;). This capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
-       href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   (&quot;Specification&quot;).</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
-   in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
-   Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur (&quot;Provisioning Process&quot;) in which a user may execute the Provisioning Technology
-       on a machine (&quot;Target Machine&quot;) with the intent of installing, extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
-       Software (&quot;Installable Software Agreement&quot;) and such Installable Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
-       the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
-       indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
-   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
-   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
 </body>
 </html>
diff --git a/org.eclipse.e4.ui.model.workbench.edit/about.html b/org.eclipse.e4.ui.model.workbench.edit/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/about.html
+++ b/org.eclipse.e4.ui.model.workbench.edit/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.e4.ui.model.workbench.edit/about.properties b/org.eclipse.e4.ui.model.workbench.edit/about.properties
index 0853b83..799160d 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/about.properties
+++ b/org.eclipse.e4.ui.model.workbench.edit/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.e4.ui.model.workbench.edit/build.properties b/org.eclipse.e4.ui.model.workbench.edit/build.properties
index 4088a74..f4bbd90 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/build.properties
+++ b/org.eclipse.e4.ui.model.workbench.edit/build.properties
@@ -1,8 +1,10 @@
 # Copyright (c) 2008, 2013 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 # 
 # Contributors:
 #      IBM Corporation - initial API and implementation
@@ -12,10 +14,10 @@
                META-INF/,\
                plugin.xml,\
                plugin.properties,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
 jars.compile.order = .
 source.. = src/
 output.. = bin/
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.e4.ui.model.workbench.edit/epl-2.0.html b/org.eclipse.e4.ui.model.workbench.edit/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.e4.ui.model.workbench.edit/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.e4.ui.model.workbench.edit/epl-v10.html b/org.eclipse.e4.ui.model.workbench.edit/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.e4.ui.model.workbench.edit/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.e4.ui.model.workbench.edit/license.html b/org.eclipse.e4.ui.model.workbench.edit/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/license.html
+++ b/org.eclipse.e4.ui.model.workbench.edit/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.e4.ui.model.workbench.edit/plugin.properties b/org.eclipse.e4.ui.model.workbench.edit/plugin.properties
index e3386ba..91f5936 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/plugin.properties
+++ b/org.eclipse.e4.ui.model.workbench.edit/plugin.properties
@@ -1,8 +1,10 @@
 # Copyright (c) 2008, 2013 IBM Corporation and others.
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 # 
 # Contributors:
 #      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/plugin.xml b/org.eclipse.e4.ui.model.workbench.edit/plugin.xml
index c5bc74b..67e65b2 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/plugin.xml
+++ b/org.eclipse.e4.ui.model.workbench.edit/plugin.xml
@@ -4,9 +4,11 @@
 <!--
  Copyright (c) 2008, 2013 IBM Corporation and others.
  All rights reserved. This program and the accompanying materials
- are made available under the terms of the Eclipse Public License v1.0
+ are made available under the terms of the Eclipse Public License 2.0 
  which accompanies this distribution, and is available at
- http://www.eclipse.org/legal/epl-v10.html
+ https://www.eclipse.org/legal/epl-2.0/
+
+ SPDX-License-Identifier: EPL-2.0
  
  Contributors:
       IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/pom.xml b/org.eclipse.e4.ui.model.workbench.edit/pom.xml
index f3b287b..b1ed106 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/pom.xml
+++ b/org.eclipse.e4.ui.model.workbench.edit/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingContextItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingContextItemProvider.java
index 84d9a3a..ad6f407 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingContextItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingContextItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingTableItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingTableItemProvider.java
index 093ad5f..2c5aeca 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingTableItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/BindingTableItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CategoryItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CategoryItemProvider.java
index c88c2cb..94c9121 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CategoryItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CategoryItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandItemProvider.java
index 440a448..f254408 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandParameterItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandParameterItemProvider.java
index 9a6d939..1f53fc3 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandParameterItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandParameterItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandsItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandsItemProviderAdapterFactory.java
index 3fd208f..ebea034 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandsItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/CommandsItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/HandlerItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/HandlerItemProvider.java
index f11a4b9..c66f1a7 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/HandlerItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/HandlerItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/KeyBindingItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/KeyBindingItemProvider.java
index 55ed379..5e7738f 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/KeyBindingItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/KeyBindingItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/ParameterItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/ParameterItemProvider.java
index 4a04767..4adc939 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/ParameterItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/commands/provider/ParameterItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/BasicItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/BasicItemProviderAdapterFactory.java
index 40d2e49..2dbd77a 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/BasicItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/BasicItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/PartDescriptorItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/PartDescriptorItemProvider.java
index de459a9..9e45682 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/PartDescriptorItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/descriptor/basic/provider/PartDescriptorItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/AddonItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/AddonItemProvider.java
index 3f0b1c3..a3f7e12 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/AddonItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/AddonItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationElementItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationElementItemProvider.java
index 4740cd4..72096f1 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationElementItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationElementItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProvider.java
index 028b82e..19063e7 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProviderAdapterFactory.java
index ef6112b..6534da9 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ApplicationItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ContributionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ContributionItemProvider.java
index 753e205..0a6ce95 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ContributionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/ContributionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToObjectMapItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToObjectMapItemProvider.java
index 9f23417..4c53496 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToObjectMapItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToObjectMapItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToStringMapItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToStringMapItemProvider.java
index 1c289d2..21819e8 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToStringMapItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/StringToStringMapItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/UIElementsEditPlugin.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/UIElementsEditPlugin.java
index 7b7a9c1..68c7244 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/UIElementsEditPlugin.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/provider/UIElementsEditPlugin.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AdvancedItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AdvancedItemProviderAdapterFactory.java
index 0d5ad0e..44217dd 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AdvancedItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AdvancedItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AreaItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AreaItemProvider.java
index 39d0e6e..65044df 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AreaItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/AreaItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveItemProvider.java
index 9dbd0de..6010610 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveStackItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveStackItemProvider.java
index d063e91..7fd8675 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveStackItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PerspectiveStackItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PlaceholderItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PlaceholderItemProvider.java
index dc88602..a8f2ba9 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PlaceholderItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/advanced/provider/PlaceholderItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/BasicItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/BasicItemProviderAdapterFactory.java
index 267373f..a78bbba 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/BasicItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/BasicItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/CompositePartItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/CompositePartItemProvider.java
index f4d4229..2384c79 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/CompositePartItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/CompositePartItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/DialogItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/DialogItemProvider.java
index 6e7edcb..749ba27 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/DialogItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/DialogItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/InputPartItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/InputPartItemProvider.java
index 777bce0..2ad669e 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/InputPartItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/InputPartItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartItemProvider.java
index 4f5d5dd..07b35d2 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartSashContainerItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartSashContainerItemProvider.java
index 4a8f78a..e464f39 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartSashContainerItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartSashContainerItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartStackItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartStackItemProvider.java
index 8aba86e..c0dd8ce 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartStackItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/PartStackItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimBarItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimBarItemProvider.java
index faf87f7..17f121d 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimBarItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimBarItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimmedWindowItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimmedWindowItemProvider.java
index 74a4941..03394c2 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimmedWindowItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/TrimmedWindowItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WindowItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WindowItemProvider.java
index b56accb..7fb8d8f 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WindowItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WindowItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WizardDialogItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WizardDialogItemProvider.java
index 0a7ca76..6547a0a 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WizardDialogItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/basic/provider/WizardDialogItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectMenuItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectMenuItemItemProvider.java
index 3296214..4825636 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectMenuItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectMenuItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectToolItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectToolItemItemProvider.java
index d592ecc..8b5ebeb 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectToolItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DirectToolItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DynamicMenuContributionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DynamicMenuContributionItemProvider.java
index cbf1da7..6413158 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DynamicMenuContributionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/DynamicMenuContributionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledItemItemProvider.java
index 3fcf31c..24a80c9 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledMenuItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledMenuItemItemProvider.java
index 0182c9a..055120e 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledMenuItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledMenuItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledToolItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledToolItemItemProvider.java
index b547573..7712caa 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledToolItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/HandledToolItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ItemItemProvider.java
index 3820d6f..2d1841b 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuContributionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuContributionItemProvider.java
index 6a0ea51..37a0abb 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuContributionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuContributionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuElementItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuElementItemProvider.java
index 856e209..19a2a71 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuElementItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuElementItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemItemProvider.java
index 3d886b3..4d018c1 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProvider.java
index b3d4859..f3ff2e9 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProviderAdapterFactory.java
index 574b9af..3bf041b 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuSeparatorItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuSeparatorItemProvider.java
index 712a02a..be264a5 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuSeparatorItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/MenuSeparatorItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/PopupMenuItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/PopupMenuItemProvider.java
index f7afcc7..2ec524c 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/PopupMenuItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/PopupMenuItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarContributionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarContributionItemProvider.java
index 32eacd2..9ba33a7 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarContributionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarContributionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarElementItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarElementItemProvider.java
index 2908a25..2073b54 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarElementItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarElementItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarItemProvider.java
index 753c05c..8c861cf 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarSeparatorItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarSeparatorItemProvider.java
index 94fbc5c..9534a87 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarSeparatorItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolBarSeparatorItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolControlItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolControlItemProvider.java
index b14dee4..9902f49 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolControlItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolControlItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolItemItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolItemItemProvider.java
index cd79bfa..c1b655d 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolItemItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/ToolItemItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/TrimContributionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/TrimContributionItemProvider.java
index 9762fc8..b63c53f 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/TrimContributionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/menu/provider/TrimContributionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/CoreExpressionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/CoreExpressionItemProvider.java
index 7943a40..eb650d1 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/CoreExpressionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/CoreExpressionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ElementContainerItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ElementContainerItemProvider.java
index 77740ed..88f88bb 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ElementContainerItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ElementContainerItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ExpressionItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ExpressionItemProvider.java
index 1c1947e..6fdd652 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ExpressionItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/ExpressionItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericStackItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericStackItemProvider.java
index 3041057..badf30e 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericStackItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericStackItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTileItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTileItemProvider.java
index 7e937de..bd42788 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTileItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTileItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTrimContainerItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTrimContainerItemProvider.java
index d6cd7e2..074ae61 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTrimContainerItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/GenericTrimContainerItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UIElementItemProvider.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UIElementItemProvider.java
index e86831c..97c7bf1 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UIElementItemProvider.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UIElementItemProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UiItemProviderAdapterFactory.java b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UiItemProviderAdapterFactory.java
index 1d6ad9c..c0b81a7 100644
--- a/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UiItemProviderAdapterFactory.java
+++ b/org.eclipse.e4.ui.model.workbench.edit/src/org/eclipse/e4/ui/model/application/ui/provider/UiItemProviderAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2008, 2013 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *      IBM Corporation - initial API and implementation
diff --git a/org.eclipse.osbp.commons/about.html b/org.eclipse.osbp.commons/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.commons/about.html
+++ b/org.eclipse.osbp.commons/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.commons/about.properties b/org.eclipse.osbp.commons/about.properties
index bb83df7..4a315d1 100644
--- a/org.eclipse.osbp.commons/about.properties
+++ b/org.eclipse.osbp.commons/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.commons/build.properties b/org.eclipse.osbp.commons/build.properties
index a138bbd..48a7870 100644
--- a/org.eclipse.osbp.commons/build.properties
+++ b/org.eclipse.osbp.commons/build.properties
@@ -2,7 +2,7 @@
 output.. = target/classes/
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.commons/epl-2.0.html b/org.eclipse.osbp.commons/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.commons/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.commons/epl-v10.html b/org.eclipse.osbp.commons/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.commons/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.commons/license.html b/org.eclipse.osbp.commons/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.commons/license.html
+++ b/org.eclipse.osbp.commons/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.commons/pom.xml b/org.eclipse.osbp.commons/pom.xml
index 0222f9c..fa53083 100644
--- a/org.eclipse.osbp.commons/pom.xml
+++ b/org.eclipse.osbp.commons/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/general/Condition.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/general/Condition.java
index 810e3ea..68fbf3b 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/general/Condition.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/general/Condition.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Bounds.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Bounds.java
index a92c54d..cc8613a 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Bounds.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Bounds.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeomUtils.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeomUtils.java
index 71b9d0c..8f4b7e8 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeomUtils.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeomUtils.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeometryHelper.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeometryHelper.java
index 20cc620..8bb86f6 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeometryHelper.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/GeometryHelper.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Rectangle.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Rectangle.java
index a1c02c8..07290d5 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Rectangle.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Rectangle.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Side.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Side.java
index c716bfe..8735092 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Side.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Side.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Vector.java b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Vector.java
index dc0c8bb..1792953 100644
--- a/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Vector.java
+++ b/org.eclipse.osbp.commons/src/org/eclipse/osbp/commons/geom/Vector.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/about.html b/org.eclipse.osbp.e4.injector.objectsuppliers/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/about.html
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/about.properties b/org.eclipse.osbp.e4.injector.objectsuppliers/about.properties
index acb5df6..291bd63 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/about.properties
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/build.properties b/org.eclipse.osbp.e4.injector.objectsuppliers/build.properties
index bcc15d4..8c34d81 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/build.properties
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/build.properties
@@ -2,8 +2,8 @@
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
                OSGI-INF/,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
 source.. = src/
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/epl-2.0.html b/org.eclipse.osbp.e4.injector.objectsuppliers/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/epl-v10.html b/org.eclipse.osbp.e4.injector.objectsuppliers/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/license.html b/org.eclipse.osbp.e4.injector.objectsuppliers/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/license.html
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/pom.xml b/org.eclipse.osbp.e4.injector.objectsuppliers/pom.xml
index fbd5b96..27fde73 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/pom.xml
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomEventObjectSupplier.java b/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomEventObjectSupplier.java
index 98b7e9f..a6f31a0 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomEventObjectSupplier.java
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomEventObjectSupplier.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomUIEventObjectSupplier.java b/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomUIEventObjectSupplier.java
index 5307918..81994fa 100644
--- a/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomUIEventObjectSupplier.java
+++ b/org.eclipse.osbp.e4.injector.objectsuppliers/src/org/eclipse/osbp/e4/injector/objectsuppliers/CustomUIEventObjectSupplier.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4extension/about.html b/org.eclipse.osbp.e4extension/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.e4extension/about.html
+++ b/org.eclipse.osbp.e4extension/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.e4extension/about.properties b/org.eclipse.osbp.e4extension/about.properties
index b4a097a..2f2b5e0 100644
--- a/org.eclipse.osbp.e4extension/about.properties
+++ b/org.eclipse.osbp.e4extension/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.e4extension/build.properties b/org.eclipse.osbp.e4extension/build.properties
index 3efd545..b424f41 100644
--- a/org.eclipse.osbp.e4extension/build.properties
+++ b/org.eclipse.osbp.e4extension/build.properties
@@ -4,7 +4,7 @@
                META-INF/,\
                .,\
                icons/,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.e4extension/epl-2.0.html b/org.eclipse.osbp.e4extension/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.e4extension/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.e4extension/epl-v10.html b/org.eclipse.osbp.e4extension/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.e4extension/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.e4extension/license.html b/org.eclipse.osbp.e4extension/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.e4extension/license.html
+++ b/org.eclipse.osbp.e4extension/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.e4extension/pom.xml b/org.eclipse.osbp.e4extension/pom.xml
index 740b4df..51b03fb 100644
--- a/org.eclipse.osbp.e4extension/pom.xml
+++ b/org.eclipse.osbp.e4extension/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/StartServiceProcessor.java b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/StartServiceProcessor.java
index f79b824..72ac550 100644
--- a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/StartServiceProcessor.java
+++ b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/StartServiceProcessor.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/impl/PartServiceExtImpl.java b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/impl/PartServiceExtImpl.java
index ffdc7e8..c886e9d 100644
--- a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/impl/PartServiceExtImpl.java
+++ b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/impl/PartServiceExtImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/service/EPartServiceExt.java b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/service/EPartServiceExt.java
index f5c6f4c..6572be7 100644
--- a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/service/EPartServiceExt.java
+++ b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/service/EPartServiceExt.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/shared/DefaultPartAddingLogic.java b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/shared/DefaultPartAddingLogic.java
index d0a36a2..e81112d 100644
--- a/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/shared/DefaultPartAddingLogic.java
+++ b/org.eclipse.osbp.e4extension/src/org/eclipse/osbp/e4extension/shared/DefaultPartAddingLogic.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4modelextension/about.html b/org.eclipse.osbp.e4modelextension/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.e4modelextension/about.html
+++ b/org.eclipse.osbp.e4modelextension/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.e4modelextension/about.properties b/org.eclipse.osbp.e4modelextension/about.properties
index f55264a..6f9cd31 100644
--- a/org.eclipse.osbp.e4modelextension/about.properties
+++ b/org.eclipse.osbp.e4modelextension/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.e4modelextension/build.properties b/org.eclipse.osbp.e4modelextension/build.properties
index da0146c..ca4cf06 100644
--- a/org.eclipse.osbp.e4modelextension/build.properties
+++ b/org.eclipse.osbp.e4modelextension/build.properties
@@ -6,9 +6,9 @@
                plugin.xml,\
                plugin.properties,\
                license.html,\
-               epl-v10.html
+               epl-2.0.html
 jars.compile.order = .
 source.. = src/
 output.. = target/classes/
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.e4modelextension/epl-2.0.html b/org.eclipse.osbp.e4modelextension/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.e4modelextension/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.e4modelextension/epl-v10.html b/org.eclipse.osbp.e4modelextension/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.e4modelextension/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.e4modelextension/license.html b/org.eclipse.osbp.e4modelextension/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.e4modelextension/license.html
+++ b/org.eclipse.osbp.e4modelextension/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.e4modelextension/pom.xml b/org.eclipse.osbp.e4modelextension/pom.xml
index eee57ee..897bd50 100644
--- a/org.eclipse.osbp.e4modelextension/pom.xml
+++ b/org.eclipse.osbp.e4modelextension/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionFactory.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionFactory.java
index 1ddd923..c2b06ae 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionFactory.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionFactory.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension;
 
 import org.eclipse.emf.ecore.EFactory;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionPackage.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionPackage.java
index c896d03..8965361 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionPackage.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/E4modelextensionPackage.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension;
 
 import org.eclipse.e4.ui.model.application.descriptor.basic.impl.BasicPackageImpl;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/EditorPartDescriptor.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/EditorPartDescriptor.java
index 4843781..cd05f04 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/EditorPartDescriptor.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/EditorPartDescriptor.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension;
 
 import org.eclipse.e4.ui.model.application.descriptor.basic.MPartDescriptor;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/VaaclipseApplication.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/VaaclipseApplication.java
index 6f04f09..3524a30 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/VaaclipseApplication.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/VaaclipseApplication.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension;
 
 import org.eclipse.e4.ui.model.application.MApplication;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionFactoryImpl.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionFactoryImpl.java
index 29595ea..a70fdbb 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionFactoryImpl.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionFactoryImpl.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.impl;
 
 import e4modelextension.*;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionPackageImpl.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionPackageImpl.java
index 9d968a9..ec53f5c 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionPackageImpl.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/E4modelextensionPackageImpl.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.impl;
 
 import e4modelextension.E4modelextensionFactory;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/EditorPartDescriptorImpl.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/EditorPartDescriptorImpl.java
index 68a1c18..b220a55 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/EditorPartDescriptorImpl.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/EditorPartDescriptorImpl.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.impl;
 
 import e4modelextension.E4modelextensionPackage;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/VaaclipseApplicationImpl.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/VaaclipseApplicationImpl.java
index c5d6afa..62f0bc3 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/VaaclipseApplicationImpl.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/impl/VaaclipseApplicationImpl.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.impl;
 
 import e4modelextension.E4modelextensionPackage;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionAdapterFactory.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionAdapterFactory.java
index 5897239..946f0f3 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionAdapterFactory.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionAdapterFactory.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.util;
 
 import e4modelextension.*;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionSwitch.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionSwitch.java
index cf2e28b..68fd6eb 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionSwitch.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/util/E4modelextensionSwitch.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.util;
 
 import e4modelextension.*;
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/EditorPartDescriptorValidator.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/EditorPartDescriptorValidator.java
index ed97b1c..51ecb2e 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/EditorPartDescriptorValidator.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/EditorPartDescriptorValidator.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.validation;
 
 /**
diff --git a/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/VaaclipseApplicationValidator.java b/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/VaaclipseApplicationValidator.java
index 3411c4d..e449d04 100644
--- a/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/VaaclipseApplicationValidator.java
+++ b/org.eclipse.osbp.e4modelextension/src/e4modelextension/validation/VaaclipseApplicationValidator.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Rushan R. Gilmullin and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0 
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * 
+ * Contributors:
+ *     Rushan R. Gilmullin - initial API and implementation
+ *******************************************************************************/
 package e4modelextension.validation;
 
 import e4modelextension.EditorPartDescriptor;
diff --git a/org.eclipse.osbp.vaaclipse.additions/about.html b/org.eclipse.osbp.vaaclipse.additions/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.additions/about.html
+++ b/org.eclipse.osbp.vaaclipse.additions/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.additions/about.properties b/org.eclipse.osbp.vaaclipse.additions/about.properties
index 5651842..a5d550b 100644
--- a/org.eclipse.osbp.vaaclipse.additions/about.properties
+++ b/org.eclipse.osbp.vaaclipse.additions/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.additions/build.properties b/org.eclipse.osbp.vaaclipse.additions/build.properties
index a138bbd..48a7870 100644
--- a/org.eclipse.osbp.vaaclipse.additions/build.properties
+++ b/org.eclipse.osbp.vaaclipse.additions/build.properties
@@ -2,7 +2,7 @@
 output.. = target/classes/
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.additions/epl-2.0.html b/org.eclipse.osbp.vaaclipse.additions/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.additions/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.additions/epl-v10.html b/org.eclipse.osbp.vaaclipse.additions/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.additions/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.additions/license.html b/org.eclipse.osbp.vaaclipse.additions/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.additions/license.html
+++ b/org.eclipse.osbp.vaaclipse.additions/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.additions/pom.xml b/org.eclipse.osbp.vaaclipse.additions/pom.xml
index f5200be..600f06a 100644
--- a/org.eclipse.osbp.vaaclipse.additions/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.additions/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewDialogContent.java b/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewDialogContent.java
index 83d1f0e..aad4dbe 100644
--- a/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewDialogContent.java
+++ b/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewDialogContent.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewHandler.java b/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewHandler.java
index e8901e6..00d915e 100644
--- a/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewHandler.java
+++ b/org.eclipse.osbp.vaaclipse.additions/src/org/eclipse/osbp/vaaclipse/additions/view/ShowViewHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/about.html b/org.eclipse.osbp.vaaclipse.api/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.api/about.html
+++ b/org.eclipse.osbp.vaaclipse.api/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.api/about.properties b/org.eclipse.osbp.vaaclipse.api/about.properties
index 3d1fed7..1191e75 100644
--- a/org.eclipse.osbp.vaaclipse.api/about.properties
+++ b/org.eclipse.osbp.vaaclipse.api/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.api/build.properties b/org.eclipse.osbp.vaaclipse.api/build.properties
index a138bbd..48a7870 100644
--- a/org.eclipse.osbp.vaaclipse.api/build.properties
+++ b/org.eclipse.osbp.vaaclipse.api/build.properties
@@ -2,7 +2,7 @@
 output.. = target/classes/
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.api/epl-2.0.html b/org.eclipse.osbp.vaaclipse.api/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.api/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.api/epl-v10.html b/org.eclipse.osbp.vaaclipse.api/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.api/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.api/license.html b/org.eclipse.osbp.vaaclipse.api/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.api/license.html
+++ b/org.eclipse.osbp.vaaclipse.api/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.api/pom.xml b/org.eclipse.osbp.vaaclipse.api/pom.xml
index 8a1acaf..36caa6e 100644
--- a/org.eclipse.osbp.vaaclipse.api/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.api/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Behaviour.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Behaviour.java
index 2b58cad..db31a7c 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Behaviour.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Behaviour.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Events.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Events.java
index 4422606..ed6023b 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Events.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/Events.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/FastViewListener.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/FastViewListener.java
index 62e15b0..7278703 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/FastViewListener.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/FastViewListener.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/MenuContributionService.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/MenuContributionService.java
index c0e6c35..ec6f051 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/MenuContributionService.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/MenuContributionService.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceInfoProvider.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceInfoProvider.java
index ddc19d3..4b07a0a 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceInfoProvider.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceInfoProvider.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceSystem.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceSystem.java
index 73ee821..e65dd19 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceSystem.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/ResourceSystem.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/VaadinExecutorService.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/VaadinExecutorService.java
index adff9b1..164d710 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/VaadinExecutorService.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/VaadinExecutorService.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/WidgetInfo.java b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/WidgetInfo.java
index e81af1c..b64163c 100644
--- a/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/WidgetInfo.java
+++ b/org.eclipse.osbp.vaaclipse.api/src/org/eclipse/osbp/vaaclipse/api/WidgetInfo.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/about.html b/org.eclipse.osbp.vaaclipse.behaviour/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/about.html
+++ b/org.eclipse.osbp.vaaclipse.behaviour/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/about.properties b/org.eclipse.osbp.vaaclipse.behaviour/about.properties
index 2f3806d..dd3ec21 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/about.properties
+++ b/org.eclipse.osbp.vaaclipse.behaviour/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/build.properties b/org.eclipse.osbp.vaaclipse.behaviour/build.properties
index f0c3547..e54a38e 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/build.properties
+++ b/org.eclipse.osbp.vaaclipse.behaviour/build.properties
@@ -4,7 +4,7 @@
                .,\
                icons/,\
                license.html,\
-               epl-v10.html
+               epl-2.0.html
 source.. = src/
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/epl-2.0.html b/org.eclipse.osbp.vaaclipse.behaviour/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.behaviour/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/epl-v10.html b/org.eclipse.osbp.vaaclipse.behaviour/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.behaviour/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/license.html b/org.eclipse.osbp.vaaclipse.behaviour/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/license.html
+++ b/org.eclipse.osbp.vaaclipse.behaviour/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/pom.xml b/org.eclipse.osbp.vaaclipse.behaviour/pom.xml
index f7b227f..24b293a 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.behaviour/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/BehaviourProcessor.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/BehaviourProcessor.java
index 6c37849..fcc9bcd 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/BehaviourProcessor.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/BehaviourProcessor.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/FastViewHandler.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/FastViewHandler.java
index 5a55eee..2917737 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/FastViewHandler.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/FastViewHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/HierarchyUtils.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/HierarchyUtils.java
index 9c94cff..be5c7a8 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/HierarchyUtils.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/HierarchyUtils.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxAddon.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxAddon.java
index 3632a09..6fad658 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxAddon.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxAddon.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2011, 2012 Kai Toedter, Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  * 	   Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxProcessor.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxProcessor.java
index d5ec483..89a6494 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxProcessor.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/MinMaxProcessor.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/RestoreHandler.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/RestoreHandler.java
index 31816ab..b961174 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/RestoreHandler.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/RestoreHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupAddon.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupAddon.java
index cbc85f0..43e57f5 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupAddon.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupAddon.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupProcessor.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupProcessor.java
index d9a67d0..22392b0 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupProcessor.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/cleanup/CleanupProcessor.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorAddon.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorAddon.java
index aaaa7f4..4739b50 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorAddon.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorAddon.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorProcessor.java b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorProcessor.java
index de9db32..2efd353 100644
--- a/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorProcessor.java
+++ b/org.eclipse.osbp.vaaclipse.behaviour/src/org/eclipse/osbp/vaaclipse/behaviour/idgenerator/ElementIdGeneratorProcessor.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/LICENSE.txt b/org.eclipse.osbp.vaaclipse.common.ecview.api/LICENSE.txt
index ff42ad4..fc5938d 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/LICENSE.txt
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/LICENSE.txt
@@ -1,161 +1,140 @@
-Eclipse Public License -v 1.0
+Eclipse Foundation Software User Agreement
 
-THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
-OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+November 22, 2017
 
-1. DEFINITIONS
+Usage Of Content
 
-"Contribution" means:
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION
+AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF
+THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE
+TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED
+BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY
+APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU
+MAY NOT USE THE CONTENT.
 
-a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+Applicable Licenses
 
-b) in the case of each subsequent Contributor:
+Unless otherwise indicated, all Content made available by the Eclipse Foundation
+is provided to you under the terms and conditions of the Eclipse Public License
+Version 2.0 ("EPL"). A copy of the EPL is provided with this Content and is also
+available at http://www.eclipse.org/legal/epl-2.0. For purposes of the EPL,
+"Program" will mean the Content.
 
-i) changes to the Program, and
+Content includes, but is not limited to, source code, object code, documentation
+and other files maintained in the Eclipse Foundation source code repository
+("Repository") in software modules ("Modules") and made available as
+downloadable archives ("Downloads").
 
-ii) additions to the Program;
+-   Content may be structured and packaged into modules to facilitate
+    delivering, extending, and upgrading the Content. Typical modules may
+    include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and
+    features ("Features").
+-   Each Plug-in or Fragment may be packaged as a sub-directory or JAR
+    (Java™ ARchive) in a directory named "plugins".
+-   A Feature is a bundle of one or more Plug-ins and/or Fragments and
+    associated material. Each Feature may be packaged as a sub-directory in a
+    directory named "features". Within a Feature, files named "feature.xml" may
+    contain a list of the names and version numbers of the Plug-ins and/or
+    Fragments associated with that Feature.
+-   Features may also include other Features ("Included Features"). Within a
+    Feature, files named "feature.xml" may contain a list of the names and
+    version numbers of Included Features.
 
-where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
-A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
-acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
-modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
-derivative works of the Program.
+The terms and conditions governing Plug-ins and Fragments should be contained in
+files named "about.html" ("Abouts"). The terms and conditions governing Features
+and Included Features should be contained in files named "license.html"
+("Feature Licenses"). Abouts and Feature Licenses may be located in any
+directory of a Download or Module including, but not limited to the following
+locations:
 
-"Contributor" means any person or entity that distributes the Program.
+-   The top-level (root) directory
+-   Plug-in and Fragment directories
+-   Inside Plug-ins and Fragments packaged as JARs
+-   Sub-directories of the directory named "src" of certain Plug-ins
+-   Feature directories
 
-"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
-its Contribution alone or when combined with the Program.
+Note: if a Feature made available by the Eclipse Foundation is installed using
+the Provisioning Technology (as defined below), you must agree to a license
+("Feature Update License") during the installation process. If the Feature
+contains Included Features, the Feature Update License should either provide you
+with the terms and conditions governing the Included Features or inform you
+where you can locate them. Feature Update Licenses may be found in the "license"
+property of files named "feature.properties" found within a Feature. Such
+Abouts, Feature Licenses, and Feature Update Licenses contain the terms and
+conditions (or references to such terms and conditions) that govern your use of
+the associated Content in that directory.
 
-"Program" means the Contributions distributed in accordance with this Agreement.
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL
+OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):
 
-"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+-   Eclipse Public License Version 1.0 (available at
+    http://www.eclipse.org/legal/epl-v10.html)
+-   Eclipse Distribution License Version 1.0 (available at
+    http://www.eclipse.org/licenses/edl-v1.0.html)
+-   Common Public License Version 1.0 (available at
+    http://www.eclipse.org/legal/cpl-v10.html)
+-   Apache Software License 1.1 (available at
+    http://www.apache.org/licenses/LICENSE)
+-   Apache Software License 2.0 (available at
+    http://www.apache.org/licenses/LICENSE-2.0)
+-   Mozilla Public License Version 1.1 (available at
+    http://www.mozilla.org/MPL/MPL-1.1.html)
 
-2. GRANT OF RIGHTS
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO
+USE OF THE CONTENT. If no About, Feature License, or Feature Update License is
+provided, please contact the Eclipse Foundation to determine what terms and
+conditions govern that particular Content.
 
-a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
-and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
-form.
+Use of Provisioning Technology
 
-b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
-Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
-combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
-addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
-apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+The Eclipse Foundation makes available provisioning software, examples of which
+include, but are not limited to, p2 and the Eclipse Update Manager
+("Provisioning Technology") for the purpose of allowing users to install
+software, documentation, information and/or other materials (collectively
+"Installable Software"). This capability is provided with the intent of allowing
+such users to install, extend and update Eclipse-based products. Information
+about packaging Installable Software is available at
+http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").
 
-c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
-assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
-rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
-based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
-licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
-rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
-Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+You may use Provisioning Technology to allow other parties to install
+Installable Software. You shall be responsible for enabling the applicable
+license agreements relating to the Installable Software to be presented to, and
+accepted by, the users of the Provisioning Technology in accordance with the
+Specification. By using Provisioning Technology in such a manner and making it
+available in accordance with the Specification, you further acknowledge your
+agreement to, and the acquisition of all necessary rights to permit the
+following:
 
-d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
-grant the copyright license set forth in this Agreement.
+1.  A series of actions may occur ("Provisioning Process") in which a user may
+    execute the Provisioning Technology on a machine ("Target Machine") with the
+    intent of installing, extending or updating the functionality of an
+    Eclipse-based product.
+2.  During the Provisioning Process, the Provisioning Technology may cause third
+    party Installable Software or a portion thereof to be accessed and copied to
+    the Target Machine.
+3.  Pursuant to the Specification, you will provide to the user the terms and
+    conditions that govern the use of the Installable Software ("Installable
+    Software Agreement") and such Installable Software Agreement shall be
+    accessed from the Target Machine in accordance with the Specification. Such
+    Installable Software Agreement must inform the user of the terms and
+    conditions that govern the Installable Software and must solicit acceptance
+    by the end user in the manner prescribed in such Installable
+    Software Agreement. Upon such indication of agreement by the user, the
+    provisioning Technology will complete installation of the
+    Installable Software.
 
-3. REQUIREMENTS
+Cryptography
 
-A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+Content may contain encryption software. The country in which you are currently
+may have restrictions on the import, possession, and use, and/or re-export to
+another country, of encryption software. BEFORE using any encryption software,
+please check the country's laws, regulations and policies concerning the import,
+possession, or use, and re-export of encryption software, to see if this is
+permitted.
 
-a) it complies with the terms and conditions of this Agreement; and
-
-b) its license agreement:
-
-i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
-warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
-fitness for a particular purpose;
-
-ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;
-
-iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
-other party; and
-
-iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
-in a reasonable manner on or through a medium customarily used for software exchange.
-
-When the Program is made available in source code form:
-
-a) it must be made available under this Agreement; and
-
-b) a copy of this Agreement must be included with each copy of the Program.
-
-Contributors may not remove or alter any copyright notices contained within the Program.
-
-Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
-subsequent Recipients to identify the originator of the Contribution.
-
-4. COMMERCIAL DISTRIBUTION
-
-Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
-the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
-the Program in a commercial product offering should do so in a manner which does not create potential liability for
-other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
-brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
-Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
-property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
-Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
-Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
- participate in any such claim at its own expense.
-
-For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
-then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
-related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
-Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
-those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
-the Commercial Contributor must pay those damages.
-
-5. NO WARRANTY
-
-EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
-CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
-NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
-determining the appropriateness of using and distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
-with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
-
-6. DISCLAIMER OF LIABILITY
-
-EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-7. GENERAL
-
-If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
-enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
-provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
-
-If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
-alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
-Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
-litigation is filed.
-
-All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
-conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
-noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
-of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
- granted by Recipient relating to the Program shall continue and survive.
-
-Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
-is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
-new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
-right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
-Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
-distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
-the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
-new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
-the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
-
-This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
-of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
-of action arose. Each party waives its rights to a jury trial in any resulting litigation.
\ No newline at end of file
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the
+United States, other countries, or both.
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/about.html b/org.eclipse.osbp.vaaclipse.common.ecview.api/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/about.html
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/about.properties b/org.eclipse.osbp.vaaclipse.common.ecview.api/about.properties
index 7cc100b..386dfce 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/about.properties
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/build.properties b/org.eclipse.osbp.vaaclipse.common.ecview.api/build.properties
index 051ae17..0f82f87 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/build.properties
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/build.properties
@@ -4,7 +4,7 @@
                .,\
                license.html,\
                LICENSE.txt,\
-               epl-v10.html
+               epl-2.0.html
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
                LICENSE.txt,\
-               epl-v10.html			   
+               epl-2.0.html			   
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/epl-2.0.html b/org.eclipse.osbp.vaaclipse.common.ecview.api/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/epl-v10.html b/org.eclipse.osbp.vaaclipse.common.ecview.api/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/license.html b/org.eclipse.osbp.vaaclipse.common.ecview.api/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/license.html
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/pom.xml b/org.eclipse.osbp.vaaclipse.common.ecview.api/pom.xml
index 6d2f72f..edfd379 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewContainer.java b/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewContainer.java
index d674f71..94ea6e0 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewContainer.java
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewContainer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewSessionHelper.java b/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewSessionHelper.java
index 389534e..84cbbf3 100644
--- a/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewSessionHelper.java
+++ b/org.eclipse.osbp.vaaclipse.common.ecview.api/src/org/eclipse/osbp/vaaclipse/common/ecview/api/IECViewSessionHelper.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.contributions/about.html b/org.eclipse.osbp.vaaclipse.contributions/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/about.html
+++ b/org.eclipse.osbp.vaaclipse.contributions/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.contributions/about.properties b/org.eclipse.osbp.vaaclipse.contributions/about.properties
index 9b05583..24a5a95 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/about.properties
+++ b/org.eclipse.osbp.vaaclipse.contributions/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.contributions/build.properties b/org.eclipse.osbp.vaaclipse.contributions/build.properties
index 4dc6f61..c8a86b7 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/build.properties
+++ b/org.eclipse.osbp.vaaclipse.contributions/build.properties
@@ -3,7 +3,7 @@
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
                plugin.xml,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.contributions/epl-2.0.html b/org.eclipse.osbp.vaaclipse.contributions/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.contributions/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.contributions/epl-v10.html b/org.eclipse.osbp.vaaclipse.contributions/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.contributions/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.contributions/license.html b/org.eclipse.osbp.vaaclipse.contributions/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/license.html
+++ b/org.eclipse.osbp.vaaclipse.contributions/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.contributions/pom.xml b/org.eclipse.osbp.vaaclipse.contributions/pom.xml
index 4390da4..59f5e06 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.contributions/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/ContributionRecord.java b/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/ContributionRecord.java
index 36c7f16..58f556b 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/ContributionRecord.java
+++ b/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/ContributionRecord.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/MenuContributionProcessor.java b/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/MenuContributionProcessor.java
index 4a1e5fc..6e4a102 100644
--- a/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/MenuContributionProcessor.java
+++ b/org.eclipse.osbp.vaaclipse.contributions/src/org/eclipse/osbp/vaaclipse/contributions/MenuContributionProcessor.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/about.html b/org.eclipse.osbp.vaaclipse.emf.addon/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.emf.addon/about.html
+++ b/org.eclipse.osbp.vaaclipse.emf.addon/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/about.properties b/org.eclipse.osbp.vaaclipse.emf.addon/about.properties
index 76c4354..f7a6bde 100644
--- a/org.eclipse.osbp.vaaclipse.emf.addon/about.properties
+++ b/org.eclipse.osbp.vaaclipse.emf.addon/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/epl-2.0.html b/org.eclipse.osbp.vaaclipse.emf.addon/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.emf.addon/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/epl-v10.html b/org.eclipse.osbp.vaaclipse.emf.addon/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.emf.addon/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/license.html b/org.eclipse.osbp.vaaclipse.emf.addon/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.emf.addon/license.html
+++ b/org.eclipse.osbp.vaaclipse.emf.addon/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/pom.xml b/org.eclipse.osbp.vaaclipse.emf.addon/pom.xml
index 0223ae7..6e028f9 100644
--- a/org.eclipse.osbp.vaaclipse.emf.addon/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.emf.addon/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf.addon/src/org/eclipse/osbp/vaaclipse/addon/EMFAddon.java b/org.eclipse.osbp.vaaclipse.emf.addon/src/org/eclipse/osbp/vaaclipse/addon/EMFAddon.java
index 438b781..9dc4cff 100644
--- a/org.eclipse.osbp.vaaclipse.emf.addon/src/org/eclipse/osbp/vaaclipse/addon/EMFAddon.java
+++ b/org.eclipse.osbp.vaaclipse.emf.addon/src/org/eclipse/osbp/vaaclipse/addon/EMFAddon.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/about.html b/org.eclipse.osbp.vaaclipse.emf.api/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/about.html
+++ b/org.eclipse.osbp.vaaclipse.emf.api/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/about.properties b/org.eclipse.osbp.vaaclipse.emf.api/about.properties
index 6fa5802..83e4359 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/about.properties
+++ b/org.eclipse.osbp.vaaclipse.emf.api/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/epl-2.0.html b/org.eclipse.osbp.vaaclipse.emf.api/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.emf.api/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/epl-v10.html b/org.eclipse.osbp.vaaclipse.emf.api/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.emf.api/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/license.html b/org.eclipse.osbp.vaaclipse.emf.api/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/license.html
+++ b/org.eclipse.osbp.vaaclipse.emf.api/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/pom.xml b/org.eclipse.osbp.vaaclipse.emf.api/pom.xml
index 953f799..8cf6dee 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.emf.api/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/dialog/IOpenModelEditDialogService.java b/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/dialog/IOpenModelEditDialogService.java
index 97c1789..21f4711 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/dialog/IOpenModelEditDialogService.java
+++ b/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/dialog/IOpenModelEditDialogService.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/perspective/IPerspectiveLayoutProvider.java b/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/perspective/IPerspectiveLayoutProvider.java
index 54da783..4a4022b 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/perspective/IPerspectiveLayoutProvider.java
+++ b/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/perspective/IPerspectiveLayoutProvider.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/view/IConstants.java b/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/view/IConstants.java
index 024d276..866328c 100644
--- a/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/view/IConstants.java
+++ b/org.eclipse.osbp.vaaclipse.emf.api/src/org/eclipse/osbp/vaaclipse/emf/api/view/IConstants.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/about.html b/org.eclipse.osbp.vaaclipse.emf/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.emf/about.html
+++ b/org.eclipse.osbp.vaaclipse.emf/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.emf/about.properties b/org.eclipse.osbp.vaaclipse.emf/about.properties
index f4cf447..b5ed7c8 100644
--- a/org.eclipse.osbp.vaaclipse.emf/about.properties
+++ b/org.eclipse.osbp.vaaclipse.emf/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.emf/build.properties b/org.eclipse.osbp.vaaclipse.emf/build.properties
index 5b0d2fa..a8c4f33 100644
--- a/org.eclipse.osbp.vaaclipse.emf/build.properties
+++ b/org.eclipse.osbp.vaaclipse.emf/build.properties
@@ -4,7 +4,7 @@
                .,\
                OSGI-INF/org.eclipse.osbp.vaaclipse.emf.ModelingContextContextFunction.xml,\
                OSGI-INF/org.eclipse.osbp.vaaclipse.emf.dialog.OpenModelEditDialog.xml,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.emf/epl-2.0.html b/org.eclipse.osbp.vaaclipse.emf/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.emf/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.emf/epl-v10.html b/org.eclipse.osbp.vaaclipse.emf/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.emf/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.emf/license.html b/org.eclipse.osbp.vaaclipse.emf/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.emf/license.html
+++ b/org.eclipse.osbp.vaaclipse.emf/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.emf/pom.xml b/org.eclipse.osbp.vaaclipse.emf/pom.xml
index 14e5ac6..04d9ac0 100644
--- a/org.eclipse.osbp.vaaclipse.emf/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.emf/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModeledUiClickController.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModeledUiClickController.java
index 93fffea..67ba20d 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModeledUiClickController.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModeledUiClickController.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContext.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContext.java
index 0854c6f..79cde85 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContext.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContext.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContextContextFunction.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContextContextFunction.java
index 65a7d99..5f553d0 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContextContextFunction.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/ModelingContextContextFunction.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/dialog/OpenModelEditDialog.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/dialog/OpenModelEditDialog.java
index eb1d0cb..ac68666 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/dialog/OpenModelEditDialog.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/dialog/OpenModelEditDialog.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewLockHandler.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewLockHandler.java
index 8de4161..debc2d0 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewLockHandler.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewLockHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewPreviousElementHandler.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewPreviousElementHandler.java
index f139920..81840e7 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewPreviousElementHandler.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/handler/EmfTreeViewPreviousElementHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfCommandStackPart.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfCommandStackPart.java
index 3f3736f..d2c982a 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfCommandStackPart.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfCommandStackPart.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfModelTreePart.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfModelTreePart.java
index 1ed12be..d0ddf44 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfModelTreePart.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfModelTreePart.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfPropertiesPart.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfPropertiesPart.java
index bf61057..71b6d3e 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfPropertiesPart.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/EmfPropertiesPart.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/JvmTypePropertiesTreePart.java b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/JvmTypePropertiesTreePart.java
index 55e7464..eee0536 100644
--- a/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/JvmTypePropertiesTreePart.java
+++ b/org.eclipse.osbp.vaaclipse.emf/src/org/eclipse/osbp/vaaclipse/emf/parts/JvmTypePropertiesTreePart.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.feature.core/build.properties b/org.eclipse.osbp.vaaclipse.feature.core/build.properties
index a1f605d..75358d3 100644
--- a/org.eclipse.osbp.vaaclipse.feature.core/build.properties
+++ b/org.eclipse.osbp.vaaclipse.feature.core/build.properties
@@ -1,6 +1,6 @@
 bin.includes = feature.xml,\
                feature.properties,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
 src.includes = license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.feature.core/epl-2.0.html b/org.eclipse.osbp.vaaclipse.feature.core/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.feature.core/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.feature.core/epl-v10.html b/org.eclipse.osbp.vaaclipse.feature.core/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.feature.core/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.feature.core/feature.properties b/org.eclipse.osbp.vaaclipse.feature.core/feature.properties
index 3fada88..b90daa1 100644
--- a/org.eclipse.osbp.vaaclipse.feature.core/feature.properties
+++ b/org.eclipse.osbp.vaaclipse.feature.core/feature.properties
@@ -1,9 +1,11 @@
 ###############################################################################
 # Copyright (c) 2013 Rushan Gilmullin, Florian Pirchner, Sopot Scela
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 # 
 # Contributors:
 #    Rushan Gilmullin, Florian Pirchner, Sopot Scela - initial API and implementation
@@ -30,9 +32,11 @@
 copyright=\
 Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 ################ end of copyright property ####################################
 
@@ -44,126 +48,143 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+\n\
+November 22, 2017\n\
 \n\
 Usage Of Content\n\
 \n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION\n\
+AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF\n\
+THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE\n\
+TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
+BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED\n\
+BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE\n\
+AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY\n\
+APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU\n\
+MAY NOT USE THE CONTENT.\n\
 \n\
 Applicable Licenses\n\
 \n\
-Unless otherwise indicated, all Content made available by the\n\
-Eclipse Foundation is provided to you under the terms and conditions of\n\
-the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is\n\
-provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
+Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
+is provided to you under the terms and conditions of the Eclipse Public License\n\
+Version 2.0 ("EPL"). A copy of the EPL is provided with this Content and is also\n\
+available at http://www.eclipse.org/legal/epl-2.0. For purposes of the EPL,\n\
+"Program" will mean the Content.\n\
 \n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse Foundation source code\n\
-repository ("Repository") in software modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
+Content includes, but is not limited to, source code, object code, documentation\n\
+and other files maintained in the Eclipse Foundation source code repository\n\
+("Repository") in software modules ("Modules") and made available as\n\
+downloadable archives ("Downloads").\n\
 \n\
-       - Content may be structured and packaged into modules to facilitate delivering,\n\
-         extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-         plug-in fragments ("Fragments"), and features ("Features").\n\
-       - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java(TM) ARchive)\n\
-         in a directory named "plugins".\n\
-       - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-         Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-         Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-         numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-       - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-         named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
+-   Content may be structured and packaged into modules to facilitate\n\
+    delivering, extending, and upgrading the Content. Typical modules may\n\
+    include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and\n\
+    features ("Features").\n\
+-   Each Plug-in or Fragment may be packaged as a sub-directory or JAR\n\
+    (Java™ ARchive) in a directory named "plugins".\n\
+-   A Feature is a bundle of one or more Plug-ins and/or Fragments and\n\
+    associated material. Each Feature may be packaged as a sub-directory in a\n\
+    directory named "features". Within a Feature, files named "feature.xml" may\n\
+    contain a list of the names and version numbers of the Plug-ins and/or\n\
+    Fragments associated with that Feature.\n\
+-   Features may also include other Features ("Included Features"). Within a\n\
+    Feature, files named "feature.xml" may contain a list of the names and\n\
+    version numbers of Included Features.\n\
 \n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
+The terms and conditions governing Plug-ins and Fragments should be contained in\n\
+files named "about.html" ("Abouts"). The terms and conditions governing Features\n\
+and Included Features should be contained in files named "license.html"\n\
+("Feature Licenses"). Abouts and Feature Licenses may be located in any\n\
+directory of a Download or Module including, but not limited to the following\n\
+locations:\n\
 \n\
-       - The top-level (root) directory\n\
-       - Plug-in and Fragment directories\n\
-       - Inside Plug-ins and Fragments packaged as JARs\n\
-       - Sub-directories of the directory named "src" of certain Plug-ins\n\
-       - Feature directories\n\
+-   The top-level (root) directory\n\
+-   Plug-in and Fragment directories\n\
+-   Inside Plug-ins and Fragments packaged as JARs\n\
+-   Sub-directories of the directory named "src" of certain Plug-ins\n\
+-   Feature directories\n\
 \n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Provisioning Technology (as defined below), you must agree to a license ("Feature \n\
-Update License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties" found within a Feature.\n\
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the\n\
-terms and conditions (or references to such terms and conditions) that\n\
-govern your use of the associated Content in that directory.\n\
+Note: if a Feature made available by the Eclipse Foundation is installed using\n\
+the Provisioning Technology (as defined below), you must agree to a license\n\
+("Feature Update License") during the installation process. If the Feature\n\
+contains Included Features, the Feature Update License should either provide you\n\
+with the terms and conditions governing the Included Features or inform you\n\
+where you can locate them. Feature Update Licenses may be found in the "license"\n\
+property of files named "feature.properties" found within a Feature. Such\n\
+Abouts, Feature Licenses, and Feature Update Licenses contain the terms and\n\
+conditions (or references to such terms and conditions) that govern your use of\n\
+the associated Content in that directory.\n\
 \n\
-THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL\n\
+OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE\n\
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
 \n\
-       - Eclipse Distribution License Version 1.0 (available at http://www.eclipse.org/licenses/edl-v1.0.html)\n\
-       - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-       - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-       - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-       - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
+-   Eclipse Public License Version 1.0 (available at\n\
+    http://www.eclipse.org/legal/epl-v10.html)\n\
+-   Eclipse Distribution License Version 1.0 (available at\n\
+    http://www.eclipse.org/licenses/edl-v1.0.html)\n\
+-   Common Public License Version 1.0 (available at\n\
+    http://www.eclipse.org/legal/cpl-v10.html)\n\
+-   Apache Software License 1.1 (available at\n\
+    http://www.apache.org/licenses/LICENSE)\n\
+-   Apache Software License 2.0 (available at\n\
+    http://www.apache.org/licenses/LICENSE-2.0)\n\
+-   Mozilla Public License Version 1.1 (available at\n\
+    http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO\n\
+USE OF THE CONTENT. If no About, Feature License, or Feature Update License is\n\
+provided, please contact the Eclipse Foundation to determine what terms and\n\
+conditions govern that particular Content.\n\
 \n\
-\n\Use of Provisioning Technology\n\
+Use of Provisioning Technology\n\
 \n\
-The Eclipse Foundation makes available provisioning software, examples of which include,\n\
-but are not limited to, p2 and the Eclipse Update Manager ("Provisioning Technology") for\n\
-the purpose of allowing users to install software, documentation, information and/or\n\
-other materials (collectively "Installable Software"). This capability is provided with\n\
-the intent of allowing such users to install, extend and update Eclipse-based products.\n\
-Information about packaging Installable Software is available at\n\
+The Eclipse Foundation makes available provisioning software, examples of which\n\
+include, but are not limited to, p2 and the Eclipse Update Manager\n\
+("Provisioning Technology") for the purpose of allowing users to install\n\
+software, documentation, information and/or other materials (collectively\n\
+"Installable Software"). This capability is provided with the intent of allowing\n\
+such users to install, extend and update Eclipse-based products. Information\n\
+about packaging Installable Software is available at\n\
 http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").\n\
 \n\
-You may use Provisioning Technology to allow other parties to install Installable Software.\n\
-You shall be responsible for enabling the applicable license agreements relating to the\n\
-Installable Software to be presented to, and accepted by, the users of the Provisioning Technology\n\
-in accordance with the Specification. By using Provisioning Technology in such a manner and\n\
-making it available in accordance with the Specification, you further acknowledge your\n\
-agreement to, and the acquisition of all necessary rights to permit the following:\n\
+You may use Provisioning Technology to allow other parties to install\n\
+Installable Software. You shall be responsible for enabling the applicable\n\
+license agreements relating to the Installable Software to be presented to, and\n\
+accepted by, the users of the Provisioning Technology in accordance with the\n\
+Specification. By using Provisioning Technology in such a manner and making it\n\
+available in accordance with the Specification, you further acknowledge your\n\
+agreement to, and the acquisition of all necessary rights to permit the\n\
+following:\n\
 \n\
-       1. A series of actions may occur ("Provisioning Process") in which a user may execute\n\
-          the Provisioning Technology on a machine ("Target Machine") with the intent of installing,\n\
-          extending or updating the functionality of an Eclipse-based product.\n\
-       2. During the Provisioning Process, the Provisioning Technology may cause third party\n\
-          Installable Software or a portion thereof to be accessed and copied to the Target Machine.\n\
-       3. Pursuant to the Specification, you will provide to the user the terms and conditions that\n\
-          govern the use of the Installable Software ("Installable Software Agreement") and such\n\
-          Installable Software Agreement shall be accessed from the Target Machine in accordance\n\
-          with the Specification. Such Installable Software Agreement must inform the user of the\n\
-          terms and conditions that govern the Installable Software and must solicit acceptance by\n\
-          the end user in the manner prescribed in such Installable Software Agreement. Upon such\n\
-          indication of agreement by the user, the provisioning Technology will complete installation\n\
-          of the Installable Software.\n\
+1.  A series of actions may occur ("Provisioning Process") in which a user may\n\
+    execute the Provisioning Technology on a machine ("Target Machine") with the\n\
+    intent of installing, extending or updating the functionality of an\n\
+    Eclipse-based product.\n\
+2.  During the Provisioning Process, the Provisioning Technology may cause third\n\
+    party Installable Software or a portion thereof to be accessed and copied to\n\
+    the Target Machine.\n\
+3.  Pursuant to the Specification, you will provide to the user the terms and\n\
+    conditions that govern the use of the Installable Software ("Installable\n\
+    Software Agreement") and such Installable Software Agreement shall be\n\
+    accessed from the Target Machine in accordance with the Specification. Such\n\
+    Installable Software Agreement must inform the user of the terms and\n\
+    conditions that govern the Installable Software and must solicit acceptance\n\
+    by the end user in the manner prescribed in such Installable\n\
+    Software Agreement. Upon such indication of agreement by the user, the\n\
+    provisioning Technology will complete installation of the\n\
+    Installable Software.\n\
 \n\
 Cryptography\n\
 \n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use, and\n\
-re-export of encryption software, to see if this is permitted.\n\
+Content may contain encryption software. The country in which you are currently\n\
+may have restrictions on the import, possession, and use, and/or re-export to\n\
+another country, of encryption software. BEFORE using any encryption software,\n\
+please check the country's laws, regulations and policies concerning the import,\n\
+possession, or use, and re-export of encryption software, to see if this is\n\
+permitted.\n\
 \n\
-Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.\n
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the\n\
+United States, other countries, or both.\n
 ########### end of license property ##########################################
diff --git a/org.eclipse.osbp.vaaclipse.feature.core/license.html b/org.eclipse.osbp.vaaclipse.feature.core/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.feature.core/license.html
+++ b/org.eclipse.osbp.vaaclipse.feature.core/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.feature.core/pom.xml b/org.eclipse.osbp.vaaclipse.feature.core/pom.xml
index 08ceefb..a5879cf 100644
--- a/org.eclipse.osbp.vaaclipse.feature.core/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.feature.core/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/build.properties b/org.eclipse.osbp.vaaclipse.feature.runtime.core/build.properties
index a1f605d..75358d3 100644
--- a/org.eclipse.osbp.vaaclipse.feature.runtime.core/build.properties
+++ b/org.eclipse.osbp.vaaclipse.feature.runtime.core/build.properties
@@ -1,6 +1,6 @@
 bin.includes = feature.xml,\
                feature.properties,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
 src.includes = license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/epl-2.0.html b/org.eclipse.osbp.vaaclipse.feature.runtime.core/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.feature.runtime.core/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/epl-v10.html b/org.eclipse.osbp.vaaclipse.feature.runtime.core/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.feature.runtime.core/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.properties b/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.properties
index fa97fe0..f806c7f 100644
--- a/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.properties
+++ b/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.properties
@@ -1,9 +1,11 @@
 ###############################################################################
 # Copyright (c) 2013 Rushan Gilmullin, Florian Pirchner, Sopot Scela
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 # 
 # Contributors:
 #    Rushan Gilmullin, Florian Pirchner, Sopot Scela - initial API and implementation
@@ -30,9 +32,11 @@
 copyright=\
 Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 ################ end of copyright property ####################################
 
@@ -44,126 +48,143 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+\n\
+November 22, 2017\n\
 \n\
 Usage Of Content\n\
 \n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION\n\
+AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF\n\
+THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE\n\
+TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
+BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED\n\
+BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE\n\
+AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY\n\
+APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU\n\
+MAY NOT USE THE CONTENT.\n\
 \n\
 Applicable Licenses\n\
 \n\
-Unless otherwise indicated, all Content made available by the\n\
-Eclipse Foundation is provided to you under the terms and conditions of\n\
-the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is\n\
-provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
+Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
+is provided to you under the terms and conditions of the Eclipse Public License\n\
+Version 2.0 ("EPL"). A copy of the EPL is provided with this Content and is also\n\
+available at http://www.eclipse.org/legal/epl-2.0. For purposes of the EPL,\n\
+"Program" will mean the Content.\n\
 \n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse Foundation source code\n\
-repository ("Repository") in software modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
+Content includes, but is not limited to, source code, object code, documentation\n\
+and other files maintained in the Eclipse Foundation source code repository\n\
+("Repository") in software modules ("Modules") and made available as\n\
+downloadable archives ("Downloads").\n\
 \n\
-       - Content may be structured and packaged into modules to facilitate delivering,\n\
-         extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-         plug-in fragments ("Fragments"), and features ("Features").\n\
-       - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java(TM) ARchive)\n\
-         in a directory named "plugins".\n\
-       - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-         Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-         Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-         numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-       - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-         named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
+-   Content may be structured and packaged into modules to facilitate\n\
+    delivering, extending, and upgrading the Content. Typical modules may\n\
+    include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and\n\
+    features ("Features").\n\
+-   Each Plug-in or Fragment may be packaged as a sub-directory or JAR\n\
+    (Java™ ARchive) in a directory named "plugins".\n\
+-   A Feature is a bundle of one or more Plug-ins and/or Fragments and\n\
+    associated material. Each Feature may be packaged as a sub-directory in a\n\
+    directory named "features". Within a Feature, files named "feature.xml" may\n\
+    contain a list of the names and version numbers of the Plug-ins and/or\n\
+    Fragments associated with that Feature.\n\
+-   Features may also include other Features ("Included Features"). Within a\n\
+    Feature, files named "feature.xml" may contain a list of the names and\n\
+    version numbers of Included Features.\n\
 \n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
+The terms and conditions governing Plug-ins and Fragments should be contained in\n\
+files named "about.html" ("Abouts"). The terms and conditions governing Features\n\
+and Included Features should be contained in files named "license.html"\n\
+("Feature Licenses"). Abouts and Feature Licenses may be located in any\n\
+directory of a Download or Module including, but not limited to the following\n\
+locations:\n\
 \n\
-       - The top-level (root) directory\n\
-       - Plug-in and Fragment directories\n\
-       - Inside Plug-ins and Fragments packaged as JARs\n\
-       - Sub-directories of the directory named "src" of certain Plug-ins\n\
-       - Feature directories\n\
+-   The top-level (root) directory\n\
+-   Plug-in and Fragment directories\n\
+-   Inside Plug-ins and Fragments packaged as JARs\n\
+-   Sub-directories of the directory named "src" of certain Plug-ins\n\
+-   Feature directories\n\
 \n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Provisioning Technology (as defined below), you must agree to a license ("Feature \n\
-Update License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties" found within a Feature.\n\
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the\n\
-terms and conditions (or references to such terms and conditions) that\n\
-govern your use of the associated Content in that directory.\n\
+Note: if a Feature made available by the Eclipse Foundation is installed using\n\
+the Provisioning Technology (as defined below), you must agree to a license\n\
+("Feature Update License") during the installation process. If the Feature\n\
+contains Included Features, the Feature Update License should either provide you\n\
+with the terms and conditions governing the Included Features or inform you\n\
+where you can locate them. Feature Update Licenses may be found in the "license"\n\
+property of files named "feature.properties" found within a Feature. Such\n\
+Abouts, Feature Licenses, and Feature Update Licenses contain the terms and\n\
+conditions (or references to such terms and conditions) that govern your use of\n\
+the associated Content in that directory.\n\
 \n\
-THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL\n\
+OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE\n\
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
 \n\
-       - Eclipse Distribution License Version 1.0 (available at http://www.eclipse.org/licenses/edl-v1.0.html)\n\
-       - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-       - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-       - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-       - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
+-   Eclipse Public License Version 1.0 (available at\n\
+    http://www.eclipse.org/legal/epl-v10.html)\n\
+-   Eclipse Distribution License Version 1.0 (available at\n\
+    http://www.eclipse.org/licenses/edl-v1.0.html)\n\
+-   Common Public License Version 1.0 (available at\n\
+    http://www.eclipse.org/legal/cpl-v10.html)\n\
+-   Apache Software License 1.1 (available at\n\
+    http://www.apache.org/licenses/LICENSE)\n\
+-   Apache Software License 2.0 (available at\n\
+    http://www.apache.org/licenses/LICENSE-2.0)\n\
+-   Mozilla Public License Version 1.1 (available at\n\
+    http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO\n\
+USE OF THE CONTENT. If no About, Feature License, or Feature Update License is\n\
+provided, please contact the Eclipse Foundation to determine what terms and\n\
+conditions govern that particular Content.\n\
 \n\
-\n\Use of Provisioning Technology\n\
+Use of Provisioning Technology\n\
 \n\
-The Eclipse Foundation makes available provisioning software, examples of which include,\n\
-but are not limited to, p2 and the Eclipse Update Manager ("Provisioning Technology") for\n\
-the purpose of allowing users to install software, documentation, information and/or\n\
-other materials (collectively "Installable Software"). This capability is provided with\n\
-the intent of allowing such users to install, extend and update Eclipse-based products.\n\
-Information about packaging Installable Software is available at\n\
+The Eclipse Foundation makes available provisioning software, examples of which\n\
+include, but are not limited to, p2 and the Eclipse Update Manager\n\
+("Provisioning Technology") for the purpose of allowing users to install\n\
+software, documentation, information and/or other materials (collectively\n\
+"Installable Software"). This capability is provided with the intent of allowing\n\
+such users to install, extend and update Eclipse-based products. Information\n\
+about packaging Installable Software is available at\n\
 http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").\n\
 \n\
-You may use Provisioning Technology to allow other parties to install Installable Software.\n\
-You shall be responsible for enabling the applicable license agreements relating to the\n\
-Installable Software to be presented to, and accepted by, the users of the Provisioning Technology\n\
-in accordance with the Specification. By using Provisioning Technology in such a manner and\n\
-making it available in accordance with the Specification, you further acknowledge your\n\
-agreement to, and the acquisition of all necessary rights to permit the following:\n\
+You may use Provisioning Technology to allow other parties to install\n\
+Installable Software. You shall be responsible for enabling the applicable\n\
+license agreements relating to the Installable Software to be presented to, and\n\
+accepted by, the users of the Provisioning Technology in accordance with the\n\
+Specification. By using Provisioning Technology in such a manner and making it\n\
+available in accordance with the Specification, you further acknowledge your\n\
+agreement to, and the acquisition of all necessary rights to permit the\n\
+following:\n\
 \n\
-       1. A series of actions may occur ("Provisioning Process") in which a user may execute\n\
-          the Provisioning Technology on a machine ("Target Machine") with the intent of installing,\n\
-          extending or updating the functionality of an Eclipse-based product.\n\
-       2. During the Provisioning Process, the Provisioning Technology may cause third party\n\
-          Installable Software or a portion thereof to be accessed and copied to the Target Machine.\n\
-       3. Pursuant to the Specification, you will provide to the user the terms and conditions that\n\
-          govern the use of the Installable Software ("Installable Software Agreement") and such\n\
-          Installable Software Agreement shall be accessed from the Target Machine in accordance\n\
-          with the Specification. Such Installable Software Agreement must inform the user of the\n\
-          terms and conditions that govern the Installable Software and must solicit acceptance by\n\
-          the end user in the manner prescribed in such Installable Software Agreement. Upon such\n\
-          indication of agreement by the user, the provisioning Technology will complete installation\n\
-          of the Installable Software.\n\
+1.  A series of actions may occur ("Provisioning Process") in which a user may\n\
+    execute the Provisioning Technology on a machine ("Target Machine") with the\n\
+    intent of installing, extending or updating the functionality of an\n\
+    Eclipse-based product.\n\
+2.  During the Provisioning Process, the Provisioning Technology may cause third\n\
+    party Installable Software or a portion thereof to be accessed and copied to\n\
+    the Target Machine.\n\
+3.  Pursuant to the Specification, you will provide to the user the terms and\n\
+    conditions that govern the use of the Installable Software ("Installable\n\
+    Software Agreement") and such Installable Software Agreement shall be\n\
+    accessed from the Target Machine in accordance with the Specification. Such\n\
+    Installable Software Agreement must inform the user of the terms and\n\
+    conditions that govern the Installable Software and must solicit acceptance\n\
+    by the end user in the manner prescribed in such Installable\n\
+    Software Agreement. Upon such indication of agreement by the user, the\n\
+    provisioning Technology will complete installation of the\n\
+    Installable Software.\n\
 \n\
 Cryptography\n\
 \n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use, and\n\
-re-export of encryption software, to see if this is permitted.\n\
+Content may contain encryption software. The country in which you are currently\n\
+may have restrictions on the import, possession, and use, and/or re-export to\n\
+another country, of encryption software. BEFORE using any encryption software,\n\
+please check the country's laws, regulations and policies concerning the import,\n\
+possession, or use, and re-export of encryption software, to see if this is\n\
+permitted.\n\
 \n\
-Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.\n
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the\n\
+United States, other countries, or both.\n
 ########### end of license property ##########################################
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.xml b/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.xml
index f47ddb1..a470319 100644
--- a/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.xml
+++ b/org.eclipse.osbp.vaaclipse.feature.runtime.core/feature.xml
@@ -2,9 +2,11 @@
 <!--#======================================================================= -->
 <!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
 <!--# All rights reserved. This program and the accompanying materials -->
-<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# are made available under the terms of the Eclipse Public License 2.0  -->
 <!--# which accompanies this distribution, and is available at -->
-<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# https://www.eclipse.org/legal/epl-2.0/    -->
+<!--#                                           -->
+<!--# SPDX-License-Identifier: EPL-2.0          -->
 <!--# -->
 <!--# Contributors: -->
 <!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial API and implementation -->
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/license.html b/org.eclipse.osbp.vaaclipse.feature.runtime.core/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.feature.runtime.core/license.html
+++ b/org.eclipse.osbp.vaaclipse.feature.runtime.core/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.feature.runtime.core/pom.xml b/org.eclipse.osbp.vaaclipse.feature.runtime.core/pom.xml
index 7834577..490c256 100644
--- a/org.eclipse.osbp.vaaclipse.feature.runtime.core/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.feature.runtime.core/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/build.properties b/org.eclipse.osbp.vaaclipse.feature.target.core/build.properties
index 94fb2b8..05e8580 100644
--- a/org.eclipse.osbp.vaaclipse.feature.target.core/build.properties
+++ b/org.eclipse.osbp.vaaclipse.feature.target.core/build.properties
@@ -1,6 +1,6 @@
 bin.includes = feature.xml,\
                feature.properties,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = epl-v10.html,\
+src.includes = epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/epl-2.0.html b/org.eclipse.osbp.vaaclipse.feature.target.core/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.feature.target.core/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/epl-v10.html b/org.eclipse.osbp.vaaclipse.feature.target.core/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.feature.target.core/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/feature.properties b/org.eclipse.osbp.vaaclipse.feature.target.core/feature.properties
index eff52b4..1ea154c 100644
--- a/org.eclipse.osbp.vaaclipse.feature.target.core/feature.properties
+++ b/org.eclipse.osbp.vaaclipse.feature.target.core/feature.properties
@@ -1,9 +1,11 @@
 ###############################################################################
 # Copyright (c) 2013 Rushan Gilmullin, Florian Pirchner, Sopot Scela
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 # 
 # Contributors:
 #    Rushan Gilmullin, Florian Pirchner, Sopot Scela - initial API and implementation
@@ -30,9 +32,11 @@
 copyright=\
 Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 ################ end of copyright property ####################################
 
@@ -44,126 +48,143 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+\n\
+November 22, 2017\n\
 \n\
 Usage Of Content\n\
 \n\
-THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
-OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
-USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
-AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
-NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU\n\
-AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
-AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
-OR NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE\n\
-TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
-OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
-BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION\n\
+AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT"). USE OF\n\
+THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE\n\
+TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
+BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED\n\
+BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE\n\
+AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW. IF YOU DO NOT AGREE TO THE\n\
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS OF ANY\n\
+APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU\n\
+MAY NOT USE THE CONTENT.\n\
 \n\
 Applicable Licenses\n\
 \n\
-Unless otherwise indicated, all Content made available by the\n\
-Eclipse Foundation is provided to you under the terms and conditions of\n\
-the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is\n\
-provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
-For purposes of the EPL, "Program" will mean the Content.\n\
+Unless otherwise indicated, all Content made available by the Eclipse Foundation\n\
+is provided to you under the terms and conditions of the Eclipse Public License\n\
+Version 2.0 ("EPL"). A copy of the EPL is provided with this Content and is also\n\
+available at http://www.eclipse.org/legal/epl-2.0. For purposes of the EPL,\n\
+"Program" will mean the Content.\n\
 \n\
-Content includes, but is not limited to, source code, object code,\n\
-documentation and other files maintained in the Eclipse Foundation source code\n\
-repository ("Repository") in software modules ("Modules") and made available\n\
-as downloadable archives ("Downloads").\n\
+Content includes, but is not limited to, source code, object code, documentation\n\
+and other files maintained in the Eclipse Foundation source code repository\n\
+("Repository") in software modules ("Modules") and made available as\n\
+downloadable archives ("Downloads").\n\
 \n\
-       - Content may be structured and packaged into modules to facilitate delivering,\n\
-         extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
-         plug-in fragments ("Fragments"), and features ("Features").\n\
-       - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java(TM) ARchive)\n\
-         in a directory named "plugins".\n\
-       - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
-         Each Feature may be packaged as a sub-directory in a directory named "features".\n\
-         Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
-         numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
-       - Features may also include other Features ("Included Features"). Within a Feature, files\n\
-         named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
+-   Content may be structured and packaged into modules to facilitate\n\
+    delivering, extending, and upgrading the Content. Typical modules may\n\
+    include plug-ins ("Plug-ins"), plug-in fragments ("Fragments"), and\n\
+    features ("Features").\n\
+-   Each Plug-in or Fragment may be packaged as a sub-directory or JAR\n\
+    (Java™ ARchive) in a directory named "plugins".\n\
+-   A Feature is a bundle of one or more Plug-ins and/or Fragments and\n\
+    associated material. Each Feature may be packaged as a sub-directory in a\n\
+    directory named "features". Within a Feature, files named "feature.xml" may\n\
+    contain a list of the names and version numbers of the Plug-ins and/or\n\
+    Fragments associated with that Feature.\n\
+-   Features may also include other Features ("Included Features"). Within a\n\
+    Feature, files named "feature.xml" may contain a list of the names and\n\
+    version numbers of Included Features.\n\
 \n\
-The terms and conditions governing Plug-ins and Fragments should be\n\
-contained in files named "about.html" ("Abouts"). The terms and\n\
-conditions governing Features and Included Features should be contained\n\
-in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
-Licenses may be located in any directory of a Download or Module\n\
-including, but not limited to the following locations:\n\
+The terms and conditions governing Plug-ins and Fragments should be contained in\n\
+files named "about.html" ("Abouts"). The terms and conditions governing Features\n\
+and Included Features should be contained in files named "license.html"\n\
+("Feature Licenses"). Abouts and Feature Licenses may be located in any\n\
+directory of a Download or Module including, but not limited to the following\n\
+locations:\n\
 \n\
-       - The top-level (root) directory\n\
-       - Plug-in and Fragment directories\n\
-       - Inside Plug-ins and Fragments packaged as JARs\n\
-       - Sub-directories of the directory named "src" of certain Plug-ins\n\
-       - Feature directories\n\
+-   The top-level (root) directory\n\
+-   Plug-in and Fragment directories\n\
+-   Inside Plug-ins and Fragments packaged as JARs\n\
+-   Sub-directories of the directory named "src" of certain Plug-ins\n\
+-   Feature directories\n\
 \n\
-Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
-Provisioning Technology (as defined below), you must agree to a license ("Feature \n\
-Update License") during the installation process. If the Feature contains\n\
-Included Features, the Feature Update License should either provide you\n\
-with the terms and conditions governing the Included Features or inform\n\
-you where you can locate them. Feature Update Licenses may be found in\n\
-the "license" property of files named "feature.properties" found within a Feature.\n\
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the\n\
-terms and conditions (or references to such terms and conditions) that\n\
-govern your use of the associated Content in that directory.\n\
+Note: if a Feature made available by the Eclipse Foundation is installed using\n\
+the Provisioning Technology (as defined below), you must agree to a license\n\
+("Feature Update License") during the installation process. If the Feature\n\
+contains Included Features, the Feature Update License should either provide you\n\
+with the terms and conditions governing the Included Features or inform you\n\
+where you can locate them. Feature Update Licenses may be found in the "license"\n\
+property of files named "feature.properties" found within a Feature. Such\n\
+Abouts, Feature Licenses, and Feature Update Licenses contain the terms and\n\
+conditions (or references to such terms and conditions) that govern your use of\n\
+the associated Content in that directory.\n\
 \n\
-THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER\n\
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
-SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL\n\
+OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS. SOME OF THESE\n\
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
 \n\
-       - Eclipse Distribution License Version 1.0 (available at http://www.eclipse.org/licenses/edl-v1.0.html)\n\
-       - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
-       - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
-       - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
-       - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
+-   Eclipse Public License Version 1.0 (available at\n\
+    http://www.eclipse.org/legal/epl-v10.html)\n\
+-   Eclipse Distribution License Version 1.0 (available at\n\
+    http://www.eclipse.org/licenses/edl-v1.0.html)\n\
+-   Common Public License Version 1.0 (available at\n\
+    http://www.eclipse.org/legal/cpl-v10.html)\n\
+-   Apache Software License 1.1 (available at\n\
+    http://www.apache.org/licenses/LICENSE)\n\
+-   Apache Software License 2.0 (available at\n\
+    http://www.apache.org/licenses/LICENSE-2.0)\n\
+-   Mozilla Public License Version 1.1 (available at\n\
+    http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
-IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
-TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License\n\
-is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
-govern that particular Content.\n\
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO\n\
+USE OF THE CONTENT. If no About, Feature License, or Feature Update License is\n\
+provided, please contact the Eclipse Foundation to determine what terms and\n\
+conditions govern that particular Content.\n\
 \n\
-\n\Use of Provisioning Technology\n\
+Use of Provisioning Technology\n\
 \n\
-The Eclipse Foundation makes available provisioning software, examples of which include,\n\
-but are not limited to, p2 and the Eclipse Update Manager ("Provisioning Technology") for\n\
-the purpose of allowing users to install software, documentation, information and/or\n\
-other materials (collectively "Installable Software"). This capability is provided with\n\
-the intent of allowing such users to install, extend and update Eclipse-based products.\n\
-Information about packaging Installable Software is available at\n\
+The Eclipse Foundation makes available provisioning software, examples of which\n\
+include, but are not limited to, p2 and the Eclipse Update Manager\n\
+("Provisioning Technology") for the purpose of allowing users to install\n\
+software, documentation, information and/or other materials (collectively\n\
+"Installable Software"). This capability is provided with the intent of allowing\n\
+such users to install, extend and update Eclipse-based products. Information\n\
+about packaging Installable Software is available at\n\
 http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").\n\
 \n\
-You may use Provisioning Technology to allow other parties to install Installable Software.\n\
-You shall be responsible for enabling the applicable license agreements relating to the\n\
-Installable Software to be presented to, and accepted by, the users of the Provisioning Technology\n\
-in accordance with the Specification. By using Provisioning Technology in such a manner and\n\
-making it available in accordance with the Specification, you further acknowledge your\n\
-agreement to, and the acquisition of all necessary rights to permit the following:\n\
+You may use Provisioning Technology to allow other parties to install\n\
+Installable Software. You shall be responsible for enabling the applicable\n\
+license agreements relating to the Installable Software to be presented to, and\n\
+accepted by, the users of the Provisioning Technology in accordance with the\n\
+Specification. By using Provisioning Technology in such a manner and making it\n\
+available in accordance with the Specification, you further acknowledge your\n\
+agreement to, and the acquisition of all necessary rights to permit the\n\
+following:\n\
 \n\
-       1. A series of actions may occur ("Provisioning Process") in which a user may execute\n\
-          the Provisioning Technology on a machine ("Target Machine") with the intent of installing,\n\
-          extending or updating the functionality of an Eclipse-based product.\n\
-       2. During the Provisioning Process, the Provisioning Technology may cause third party\n\
-          Installable Software or a portion thereof to be accessed and copied to the Target Machine.\n\
-       3. Pursuant to the Specification, you will provide to the user the terms and conditions that\n\
-          govern the use of the Installable Software ("Installable Software Agreement") and such\n\
-          Installable Software Agreement shall be accessed from the Target Machine in accordance\n\
-          with the Specification. Such Installable Software Agreement must inform the user of the\n\
-          terms and conditions that govern the Installable Software and must solicit acceptance by\n\
-          the end user in the manner prescribed in such Installable Software Agreement. Upon such\n\
-          indication of agreement by the user, the provisioning Technology will complete installation\n\
-          of the Installable Software.\n\
+1.  A series of actions may occur ("Provisioning Process") in which a user may\n\
+    execute the Provisioning Technology on a machine ("Target Machine") with the\n\
+    intent of installing, extending or updating the functionality of an\n\
+    Eclipse-based product.\n\
+2.  During the Provisioning Process, the Provisioning Technology may cause third\n\
+    party Installable Software or a portion thereof to be accessed and copied to\n\
+    the Target Machine.\n\
+3.  Pursuant to the Specification, you will provide to the user the terms and\n\
+    conditions that govern the use of the Installable Software ("Installable\n\
+    Software Agreement") and such Installable Software Agreement shall be\n\
+    accessed from the Target Machine in accordance with the Specification. Such\n\
+    Installable Software Agreement must inform the user of the terms and\n\
+    conditions that govern the Installable Software and must solicit acceptance\n\
+    by the end user in the manner prescribed in such Installable\n\
+    Software Agreement. Upon such indication of agreement by the user, the\n\
+    provisioning Technology will complete installation of the\n\
+    Installable Software.\n\
 \n\
 Cryptography\n\
 \n\
-Content may contain encryption software. The country in which you are\n\
-currently may have restrictions on the import, possession, and use,\n\
-and/or re-export to another country, of encryption software. BEFORE\n\
-using any encryption software, please check the country's laws,\n\
-regulations and policies concerning the import, possession, or use, and\n\
-re-export of encryption software, to see if this is permitted.\n\
+Content may contain encryption software. The country in which you are currently\n\
+may have restrictions on the import, possession, and use, and/or re-export to\n\
+another country, of encryption software. BEFORE using any encryption software,\n\
+please check the country's laws, regulations and policies concerning the import,\n\
+possession, or use, and re-export of encryption software, to see if this is\n\
+permitted.\n\
 \n\
-Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.\n
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the\n\
+United States, other countries, or both.\n
 ########### end of license property ##########################################
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/feature.xml b/org.eclipse.osbp.vaaclipse.feature.target.core/feature.xml
index 44d9ce0..e0b381b 100644
--- a/org.eclipse.osbp.vaaclipse.feature.target.core/feature.xml
+++ b/org.eclipse.osbp.vaaclipse.feature.target.core/feature.xml
@@ -2,9 +2,11 @@
 <!--#======================================================================= -->
 <!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) -->
 <!--# All rights reserved. This program and the accompanying materials -->
-<!--# are made available under the terms of the Eclipse Public License v1.0 -->
+<!--# are made available under the terms of the Eclipse Public License 2.0  -->
 <!--# which accompanies this distribution, and is available at -->
-<!--# http://www.eclipse.org/legal/epl-v10.html -->
+<!--# https://www.eclipse.org/legal/epl-2.0/    -->
+<!--#                                           -->
+<!--# SPDX-License-Identifier: EPL-2.0          -->
 <!--# -->
 <!--# Contributors: -->
 <!--#     Christophe Loetz (Loetz GmbH&Co.KG) - initial API and implementation -->
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/license.html b/org.eclipse.osbp.vaaclipse.feature.target.core/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.feature.target.core/license.html
+++ b/org.eclipse.osbp.vaaclipse.feature.target.core/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.feature.target.core/pom.xml b/org.eclipse.osbp.vaaclipse.feature.target.core/pom.xml
index fab007e..53f5d62 100644
--- a/org.eclipse.osbp.vaaclipse.feature.target.core/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.feature.target.core/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/about.html b/org.eclipse.osbp.vaaclipse.presentation/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/about.html
+++ b/org.eclipse.osbp.vaaclipse.presentation/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.presentation/about.properties b/org.eclipse.osbp.vaaclipse.presentation/about.properties
index 3d71a0a..09c82ec 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/about.properties
+++ b/org.eclipse.osbp.vaaclipse.presentation/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.presentation/build.properties b/org.eclipse.osbp.vaaclipse.presentation/build.properties
index 63bcba4..8607dda 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/build.properties
+++ b/org.eclipse.osbp.vaaclipse.presentation/build.properties
@@ -4,7 +4,7 @@
                .,\
                plugin.xml,\
                license.html,\
-               epl-v10.html
+               epl-2.0.html
 
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.presentation/epl-2.0.html b/org.eclipse.osbp.vaaclipse.presentation/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.presentation/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.presentation/epl-v10.html b/org.eclipse.osbp.vaaclipse.presentation/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.presentation/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.presentation/license.html b/org.eclipse.osbp.vaaclipse.presentation/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/license.html
+++ b/org.eclipse.osbp.vaaclipse.presentation/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.presentation/pom.xml b/org.eclipse.osbp.vaaclipse.presentation/pom.xml
index 6f81e7a..69b6b68 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.presentation/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/Activator.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/Activator.java
index 4cd8d8f..7dd74cf 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/Activator.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/Activator.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/dnd/VaadinDropHandler.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/dnd/VaadinDropHandler.java
index 258b0f9..544e8de 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/dnd/VaadinDropHandler.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/dnd/VaadinDropHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/emf/RecordingCommand.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/emf/RecordingCommand.java
index 3b23412..750fc2e 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/emf/RecordingCommand.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/emf/RecordingCommand.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericPresentationEngine.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericPresentationEngine.java
index ae4ecf0..bc471fe 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericPresentationEngine.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericPresentationEngine.java
@@ -2,9 +2,11 @@
  * Copyright (c) 2011 Kai Toedter, Rushan R. Gilmullin and others.
  * 
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html.
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *.
+ * SPDX-License-Identifier: EPL-2.0.
  * 
  * Contributors:
  *     Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericRendererFactory.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericRendererFactory.java
index 02a0ac4..9593458 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericRendererFactory.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/GenericRendererFactory.java
@@ -2,9 +2,11 @@
  * Copyright (c) 2011 Kai Toedter and others.
  * 
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html.
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *.
+ * SPDX-License-Identifier: EPL-2.0.
  * 
  * Contributors:
  *     Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/PresentationEngine.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/PresentationEngine.java
index c80279f..2d881d6 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/PresentationEngine.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/PresentationEngine.java
@@ -2,9 +2,11 @@
  * Copyright (c) 2011 Kai Toedter and others.
  * 
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html.
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *.
+ * SPDX-License-Identifier: EPL-2.0.
  * 
  * Contributors:
  *     Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/RendererFactory.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/RendererFactory.java
index 9ecfeba..fbf30e6 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/RendererFactory.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/RendererFactory.java
@@ -2,9 +2,11 @@
  * Copyright (c) 2011 Kai Toedter and others.
  * 
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html.
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *.
+ * SPDX-License-Identifier: EPL-2.0.
  * 
  * Contributors:
  *     Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/VaadinPresentationEngine.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/VaadinPresentationEngine.java
index 2a0edc2..b21e889 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/VaadinPresentationEngine.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/engine/VaadinPresentationEngine.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/FastViewManager.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/FastViewManager.java
index 6e6b02e..6e959f8 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/FastViewManager.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/FastViewManager.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/SingleElementFastViewManager.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/SingleElementFastViewManager.java
index adfa690..a996015 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/SingleElementFastViewManager.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/fastview/SingleElementFastViewManager.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/AreaRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/AreaRenderer.java
index 2f13255..be11ec3 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/AreaRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/AreaRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/BasicMenuToolbarTrimbarRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/BasicMenuToolbarTrimbarRenderer.java
index a1c434c..54806fe 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/BasicMenuToolbarTrimbarRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/BasicMenuToolbarTrimbarRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/GenericRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/GenericRenderer.java
index f047f89..2ea8e68 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/GenericRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/GenericRenderer.java
@@ -2,9 +2,11 @@
  * Copyright (c) 2011 Kai Toedter and others.
  * 
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html.
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *.
+ * SPDX-License-Identifier: EPL-2.0.
  * 
  * Contributors:
  *     Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ItemRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ItemRenderer.java
index 4120d61..2a08ad3 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ItemRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ItemRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
@@ -63,6 +65,10 @@
 				public void run() {
 					updateItemEnablement(item);
 				}
+				
+				public String toString(){
+					return item.toString();
+				}
 			};
 			this.enabledUpdaters.put(item, runnable);
 			executorService.invokeLaterAlways(runnable);
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuItemRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuItemRenderer.java
index fd60b02..23d4811 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuItemRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuItemRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuRenderer.java
index 6d21096..1603af4 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuSeparatorRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuSeparatorRenderer.java
index 1b775bf..8436b86 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuSeparatorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/MenuSeparatorRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PartRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PartRenderer.java
index 4f870b0..67085c0 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PartRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PartRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
@@ -37,8 +39,10 @@
 import org.osgi.service.event.Event;
 import org.osgi.service.event.EventHandler;
 
+import com.vaadin.event.LayoutEvents.LayoutClickEvent;
 import com.vaadin.ui.AbstractLayout;
 import com.vaadin.ui.Component;
+import com.vaadin.ui.Component.Focusable;
 import com.vaadin.ui.ComponentContainer;
 import com.vaadin.ui.CssLayout;
 import com.vaadin.ui.Panel;
@@ -125,6 +129,11 @@
 		localContext.set(IPartItemExecutionService.class, new PartItemExecutionService());
 
 		pane.addLayoutClickListener(e -> {
+			if(e.getClickedComponent() instanceof Focusable) {
+				localContext.set(LayoutClickEvent.class, e);
+			} else {
+				localContext.set(LayoutClickEvent.class, null);
+			}
 			localContext.activate();
 		});
 
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveRenderer.java
index 8e24861..3781c9d 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveStackRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveStackRenderer.java
index 5d57dd8..b58e9c7 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveStackRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PerspectiveStackRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PlaceholderRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PlaceholderRenderer.java
index e3f043d..feb4e1c 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PlaceholderRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/PlaceholderRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/SashRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/SashRenderer.java
index 970c2b5..26570b2 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/SashRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/SashRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/StackRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/StackRenderer.java
index 42fbe57..61491d6 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/StackRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/StackRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarContributionRecord.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarContributionRecord.java
index 5d9e89d..6e6e30e 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarContributionRecord.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarContributionRecord.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2011, 2012 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarRenderer.java
index 64401ac..29a6269 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolBarRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
@@ -244,12 +246,12 @@
 														// element is toolbar
 														// drag handler
 														// (separator)
-		if (element instanceof MToolBarSeparator) {
-			toolbarWidget
-					.addComponent(GuiUtils.createSeparator(toolBar), index);
-		} else {
+//		if (element instanceof MToolBarSeparator) {
+//			toolbarWidget
+//					.addComponent(GuiUtils.createSeparator(toolBar), index);
+//		} else {
 			toolbarWidget.addComponent(childWidget, index);
-		}
+//		}
 
 		toolbarWidget.requestRepaint();
 	}
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolControlRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolControlRenderer.java
index e08acf6..bf48152 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolControlRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolControlRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolItemRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolItemRenderer.java
index 87658d5..0fa8460 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolItemRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/ToolItemRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
@@ -28,6 +30,7 @@
 import org.eclipse.e4.ui.model.application.ui.menu.MHandledToolItem;
 import org.eclipse.e4.ui.model.application.ui.menu.MItem;
 import org.eclipse.e4.ui.model.application.ui.menu.MToolBarElement;
+import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
 import org.eclipse.e4.ui.model.application.ui.menu.MToolItem;
 import org.eclipse.e4.ui.services.internal.events.EventBroker;
 import org.eclipse.e4.ui.workbench.UIEvents;
@@ -204,6 +207,14 @@
 			updateItemEnablement(item);
 			button.setEnabled(item.isEnabled());
 			registerEnablementUpdaters(item);
+		}else if(element instanceof MToolBarSeparator){
+			ToolbarButton fakeButton = new ToolbarButton();
+			fakeButton.setType(Type.Link);
+			fakeButton.setLabelAndIcon("", "");
+			fakeButton.setDescription("");
+			fakeButton.setEnabled(false);
+			fakeButton.addStyleName("v-spliter");
+			element.setWidget(fakeButton);
 		}
 	}
 
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/TrimBarRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/TrimBarRenderer.java
index 8c39969..8b37da2 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/TrimBarRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/TrimBarRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRenderer.java
index d3a3944..bafe90e 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRenderer.java
@@ -2,9 +2,11 @@
  * Copyright (c) 2011 Kai Toedter, Rushan R. Gilmullin and others.
  * 
  * All rights reserved. This program and the accompanying materials 
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html.
+ * https://www.eclipse.org/legal/epl-2.0/.
+ *.
+ * SPDX-License-Identifier: EPL-2.0.
  * 
  * Contributors:
  *     Kai Toedter - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRendererFactory.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRendererFactory.java
index e739d67..5f228e2 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRendererFactory.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/VaadinRendererFactory.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
@@ -29,6 +31,7 @@
 import org.eclipse.e4.ui.model.application.ui.menu.MMenuItem;
 import org.eclipse.e4.ui.model.application.ui.menu.MMenuSeparator;
 import org.eclipse.e4.ui.model.application.ui.menu.MToolBar;
+import org.eclipse.e4.ui.model.application.ui.menu.MToolBarSeparator;
 import org.eclipse.e4.ui.model.application.ui.menu.MToolControl;
 import org.eclipse.e4.ui.model.application.ui.menu.MToolItem;
 import org.eclipse.osbp.vaaclipse.presentation.engine.GenericRendererFactory;
@@ -97,7 +100,7 @@
 						ToolBarRenderer.class, context);
 			}
 			return toolBarRenderer;
-		} else if (uiElement instanceof MToolItem) {
+		} else if (uiElement instanceof MToolItem || uiElement instanceof MToolBarSeparator) {
 			if (toolItemRenderer == null) {
 				toolItemRenderer = ContextInjectionFactory.make(
 						ToolItemRenderer.class, context);
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/WorkbenchWindowRenderer.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/WorkbenchWindowRenderer.java
index 705ff60..27b1ffe 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/WorkbenchWindowRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/WorkbenchWindowRenderer.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/callback/PartItemExecutionService.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/callback/PartItemExecutionService.java
index 50e761e..de1cb38 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/callback/PartItemExecutionService.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/renderers/callback/PartItemExecutionService.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/Commons.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/Commons.java
index 458ef21..de28065 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/Commons.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/Commons.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/GuiUtils.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/GuiUtils.java
index f72cc39..490c031 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/GuiUtils.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/GuiUtils.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/HierarchyUtils.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/HierarchyUtils.java
index d67a9b4..ff2fad1 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/HierarchyUtils.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/utils/HierarchyUtils.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgetinfo/WidgetInfoImpl.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgetinfo/WidgetInfoImpl.java
index 646c4fc..5442bc3 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgetinfo/WidgetInfoImpl.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgetinfo/WidgetInfoImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgets/TrimmedWindowContent.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgets/TrimmedWindowContent.java
index 52361ab..6ea9889 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgets/TrimmedWindowContent.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/presentation/widgets/TrimmedWindowContent.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
@@ -11,6 +13,7 @@
 
 package org.eclipse.osbp.vaaclipse.presentation.widgets;
 
+import com.vaadin.ui.Alignment;
 import com.vaadin.ui.Component;
 import com.vaadin.ui.GridLayout;
 import com.vaadin.ui.HorizontalLayout;
@@ -66,8 +69,8 @@
 		// Top panel - it contains the top trimbar and the perspective stack
 		// panel
 		topContainerPanel = new GridLayout(2, 1);
-		topContainerPanel.setColumnExpandRatio(0, 100);
-		topContainerPanel.setColumnExpandRatio(1, 0);
+		topContainerPanel.setColumnExpandRatio(0, 0);
+		topContainerPanel.setColumnExpandRatio(1, 100);
 		topContainerPanel.setSizeUndefined();
 		topContainerPanel.setWidth("100%");
 
@@ -101,15 +104,15 @@
 	}
 
 	public HorizontalLayout getPerspectiveStackPanel() {
-		return (HorizontalLayout) topContainerPanel.getComponent(0, 1);
+		return (HorizontalLayout) topContainerPanel.getComponent(0, 0);
 	}
 
 	public void setPerspectiveStackPanel(HorizontalLayout perspectiveStackPanel) {
 		if (perspectiveStackPanel == null) {
-			this.topContainerPanel.removeComponent(1, 0);
+			this.topContainerPanel.removeComponent(0, 0);
 		} else {
 			perspectiveStackPanel.setSizeUndefined();
-			this.topContainerPanel.addComponent(perspectiveStackPanel, 1, 0);
+			this.topContainerPanel.addComponent(perspectiveStackPanel, 0, 0);
 		}
 	}
 
@@ -145,19 +148,25 @@
 
 	public void setTopBar(Component bar) {
 		if (bar == null) {
-			this.topContainerPanel.removeComponent(0, 0);
+			this.topContainerPanel.removeComponent(1, 0);
 			return;
 		}
 
-		if (this.topContainerPanel.getComponent(0, 0) != null) {
-			this.topContainerPanel.removeComponent(0, 0);
+		if (this.topContainerPanel.getComponent(1, 0) != null) {
+			this.topContainerPanel.removeComponent(1, 0);
 		}
 
-		this.topContainerPanel.addComponent(bar, 0, 0);
+		HorizontalLayout topBarWrapper = new HorizontalLayout();
+		topBarWrapper.setWidth("100%");
+		topBarWrapper.addComponent(bar);
+		topBarWrapper.setComponentAlignment(bar, Alignment.MIDDLE_RIGHT);
+		bar.setSizeUndefined();
+		
+		this.topContainerPanel.addComponent(topBarWrapper, 1, 0);
 	}
 
 	public Component getTopbar() {
-		return this.topContainerPanel.getComponent(0, 0);
+		return this.topContainerPanel.getComponent(1, 0);
 	}
 
 	// -----------------------------------
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidget.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidget.java
index 9aec488..963ba06 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidget.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidget.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetExtension.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetExtension.java
index 4372cf8..fc8d65b 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetExtension.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetExtension.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetHorizontal.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetHorizontal.java
index d55eaff..eb5f5d4 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetHorizontal.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetHorizontal.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetVertical.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetVertical.java
index 2848d87..c987358 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetVertical.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SashWidgetVertical.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SplitPositionChangedListener.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SplitPositionChangedListener.java
index 7e5ddec..c618198 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SplitPositionChangedListener.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/SplitPositionChangedListener.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButton.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButton.java
index 7285ae5..5adc5fc 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButton.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButton.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButtonBase.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButtonBase.java
index 6fc942f..0cda9e6 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButtonBase.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/ToolbarButtonBase.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/TwoStateToolbarButton.java b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/TwoStateToolbarButton.java
index 371b11c..c8efef6 100644
--- a/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/TwoStateToolbarButton.java
+++ b/org.eclipse.osbp.vaaclipse.presentation/src/org/eclipse/osbp/vaaclipse/widgets/TwoStateToolbarButton.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/about.html b/org.eclipse.osbp.vaaclipse.publicapi/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/about.html
+++ b/org.eclipse.osbp.vaaclipse.publicapi/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/about.properties b/org.eclipse.osbp.vaaclipse.publicapi/about.properties
index 6a61dfd..5d9738a 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/about.properties
+++ b/org.eclipse.osbp.vaaclipse.publicapi/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/build.properties b/org.eclipse.osbp.vaaclipse.publicapi/build.properties
index a138bbd..48a7870 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/build.properties
+++ b/org.eclipse.osbp.vaaclipse.publicapi/build.properties
@@ -2,7 +2,7 @@
 output.. = target/classes/
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/epl-2.0.html b/org.eclipse.osbp.vaaclipse.publicapi/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.publicapi/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/epl-v10.html b/org.eclipse.osbp.vaaclipse.publicapi/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.publicapi/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/license.html b/org.eclipse.osbp.vaaclipse.publicapi/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/license.html
+++ b/org.eclipse.osbp.vaaclipse.publicapi/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/pom.xml b/org.eclipse.osbp.vaaclipse.publicapi/pom.xml
index c8dbe12..bbeb365 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.publicapi/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/app/ThreadLocals.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/app/ThreadLocals.java
index e0b96a1..b898c30 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/app/ThreadLocals.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/app/ThreadLocals.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/authentication/AuthenticationConstants.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/authentication/AuthenticationConstants.java
index 5440880..ced9154 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/authentication/AuthenticationConstants.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/authentication/AuthenticationConstants.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangeCommand.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangeCommand.java
index 61eebd7..251fa59 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangeCommand.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangeCommand.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangedRecorder.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangedRecorder.java
index b8849e1..2163895 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangedRecorder.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/ChangedRecorder.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/SimpleCommand.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/SimpleCommand.java
index 8720e5a..0cd3997 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/SimpleCommand.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/change/SimpleCommand.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/commands/IPartItemExecutionService.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/commands/IPartItemExecutionService.java
index 6881ba7..bef7b73 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/commands/IPartItemExecutionService.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/commands/IPartItemExecutionService.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/debug/IOwningWorkspaceAccess.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/debug/IOwningWorkspaceAccess.java
index 66b6021..8360909 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/debug/IOwningWorkspaceAccess.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/debug/IOwningWorkspaceAccess.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/editor/SavePromptSetup.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/editor/SavePromptSetup.java
index c65bc3a..f71908c 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/editor/SavePromptSetup.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/editor/SavePromptSetup.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/IWidgetModelAssociations.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/IWidgetModelAssociations.java
index 5acd6fd..0804d29 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/IWidgetModelAssociations.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/IWidgetModelAssociations.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/PublicEvents.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/PublicEvents.java
index 2b15e48..e4e9068 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/PublicEvents.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/PublicEvents.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/VaaclipseUiEvents.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/VaaclipseUiEvents.java
index 5aa8b3b..84be20c 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/VaaclipseUiEvents.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/events/VaaclipseUiEvents.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/model/Tags.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/model/Tags.java
index e5fbc5a..efa940c 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/model/Tags.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/model/Tags.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/perspective/IPerspectiveHandler.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/perspective/IPerspectiveHandler.java
index a71da50..0871cd9 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/perspective/IPerspectiveHandler.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/perspective/IPerspectiveHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2000, 2008 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/preferences/IPreferenceProvider.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/preferences/IPreferenceProvider.java
index af04b1a..66b0a0b 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/preferences/IPreferenceProvider.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/preferences/IPreferenceProvider.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/BundleResource.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/BundleResource.java
index ebc318d..f5ba3d9 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/BundleResource.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/BundleResource.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/ResourceHelper.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/ResourceHelper.java
index c9b34ac..f9dee92 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/ResourceHelper.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/resources/ResourceHelper.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/Theme.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/Theme.java
index a64e1e6..afa9f4b 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/Theme.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/Theme.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeConstants.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeConstants.java
index 002be80..8d2f686 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeConstants.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeConstants.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeContribution.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeContribution.java
index b3552bf..c55e72b 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeContribution.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeContribution.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEngine.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEngine.java
index ba37aa7..a9b1ce8 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEngine.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEngine.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEntry.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEntry.java
index f07f548..de63394 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEntry.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeEntry.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeManager.java b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeManager.java
index 6269fa1..fdb8591 100644
--- a/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeManager.java
+++ b/org.eclipse.osbp.vaaclipse.publicapi/src/org/eclipse/osbp/vaaclipse/publicapi/theme/ThemeManager.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.resources/about.html b/org.eclipse.osbp.vaaclipse.resources/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.resources/about.html
+++ b/org.eclipse.osbp.vaaclipse.resources/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.resources/about.properties b/org.eclipse.osbp.vaaclipse.resources/about.properties
index 3ed0b99..aa34181 100644
--- a/org.eclipse.osbp.vaaclipse.resources/about.properties
+++ b/org.eclipse.osbp.vaaclipse.resources/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.resources/build.properties b/org.eclipse.osbp.vaaclipse.resources/build.properties
index 46c6987..c4a054f 100644
--- a/org.eclipse.osbp.vaaclipse.resources/build.properties
+++ b/org.eclipse.osbp.vaaclipse.resources/build.properties
@@ -3,7 +3,7 @@
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
                VAADIN/,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.resources/epl-2.0.html b/org.eclipse.osbp.vaaclipse.resources/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.resources/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.resources/epl-v10.html b/org.eclipse.osbp.vaaclipse.resources/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.resources/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.resources/license.html b/org.eclipse.osbp.vaaclipse.resources/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.resources/license.html
+++ b/org.eclipse.osbp.vaaclipse.resources/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.resources/pom.xml b/org.eclipse.osbp.vaaclipse.resources/pom.xml
index 3534be3..14e944b 100644
--- a/org.eclipse.osbp.vaaclipse.resources/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.resources/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.target.juno/pom.xml b/org.eclipse.osbp.vaaclipse.target.juno/pom.xml
index 163a316..46d4a6c 100644
--- a/org.eclipse.osbp.vaaclipse.target.juno/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.target.juno/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.target.luna/pom.xml b/org.eclipse.osbp.vaaclipse.target.luna/pom.xml
index cd42a9b..9fdc032 100644
--- a/org.eclipse.osbp.vaaclipse.target.luna/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.target.luna/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/about.html b/org.eclipse.osbp.vaaclipse.theme/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.theme/about.html
+++ b/org.eclipse.osbp.vaaclipse.theme/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.theme/about.properties b/org.eclipse.osbp.vaaclipse.theme/about.properties
index f12caf5..84081a0 100644
--- a/org.eclipse.osbp.vaaclipse.theme/about.properties
+++ b/org.eclipse.osbp.vaaclipse.theme/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.theme/build.properties b/org.eclipse.osbp.vaaclipse.theme/build.properties
index 87ee705..b8c34ed 100644
--- a/org.eclipse.osbp.vaaclipse.theme/build.properties
+++ b/org.eclipse.osbp.vaaclipse.theme/build.properties
@@ -7,7 +7,7 @@
                schema/,\
                OSGI-INF/,\
                license.html,\
-               epl-v10.html
+               epl-2.0.html
 source.. = src/
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.theme/epl-2.0.html b/org.eclipse.osbp.vaaclipse.theme/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.theme/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.theme/epl-v10.html b/org.eclipse.osbp.vaaclipse.theme/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.theme/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.theme/license.html b/org.eclipse.osbp.vaaclipse.theme/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.theme/license.html
+++ b/org.eclipse.osbp.vaaclipse.theme/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.theme/pom.xml b/org.eclipse.osbp.vaaclipse.theme/pom.xml
index 80b3a5e..69175a8 100644
--- a/org.eclipse.osbp.vaaclipse.theme/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.theme/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeContributionImpl.java b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeContributionImpl.java
index f55a577..18286d3 100644
--- a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeContributionImpl.java
+++ b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeContributionImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEngineImpl.java b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEngineImpl.java
index 7d4131e..e7c7a9f 100644
--- a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEngineImpl.java
+++ b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEngineImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEntryImpl.java b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEntryImpl.java
index 8f8f74e..f2d19f5 100644
--- a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEntryImpl.java
+++ b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeEntryImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeImpl.java b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeImpl.java
index 2af070b..115d90f 100644
--- a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeImpl.java
+++ b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerContextFunction.java b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerContextFunction.java
index f647dfc..9e90824 100644
--- a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerContextFunction.java
+++ b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerContextFunction.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerImpl.java b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerImpl.java
index 69949c3..970d23d 100644
--- a/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerImpl.java
+++ b/org.eclipse.osbp.vaaclipse.theme/src/org/eclipse/osbp/vaaclipse/theme/ThemeManagerImpl.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.html b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.html
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.properties b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.properties
index 837e074..8ecec4a 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.properties
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/build.properties b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/build.properties
index 7f492ff..b426410 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/build.properties
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/build.properties
@@ -5,12 +5,12 @@
                css/,\
                img/,\
                OSGI-INF/org.eclipse.osbp.vaaclipse.ui.preferences.addon.internal.service.PreferenceProviderContextFunction.xml,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
                OSGI-INF/org.osbp.vaaclipse.ui.preferences.addon.internal.service.PreferenceProviderContextFunction.xml,\
                OSGI-INF/
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  css/,\
                img/,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
 source.. = src/
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/epl-2.0.html b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/epl-v10.html b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/license.html b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/license.html
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/pom.xml b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/pom.xml
index cf0ff90..e041f32 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ExportPreferencesHandler.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ExportPreferencesHandler.java
index 559c7a6..db30d58 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ExportPreferencesHandler.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ExportPreferencesHandler.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ImportPreferencesHandler.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ImportPreferencesHandler.java
index 1a062c9..9d7f75a 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ImportPreferencesHandler.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/ImportPreferencesHandler.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/OpenPreferencesDialogHandler.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/OpenPreferencesDialogHandler.java
index def9806..7e781ec 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/OpenPreferencesDialogHandler.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/OpenPreferencesDialogHandler.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAddon.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAddon.java
index 0d9ce26..a11a9d7 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAddon.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAddon.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAuthorization.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAuthorization.java
index f799c60..cb07432 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAuthorization.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesAuthorization.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesEvents.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesEvents.java
index e387bdf..52a57d2 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesEvents.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/PreferencesEvents.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/BooleanFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/BooleanFieldEditorRenderer.java
index d494606..6de35e3 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/BooleanFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/BooleanFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ComboFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ComboFieldEditorRenderer.java
index 8859f29..917821d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ComboFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ComboFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/FieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/FieldEditorRenderer.java
index b0c3742..5d32f24 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/FieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/FieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/IntegerFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/IntegerFieldEditorRenderer.java
index a4e3c43..0a1b640 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/IntegerFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/IntegerFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListEditorRenderer.java
index a9f05aa..e3303d5 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListFieldEditorRenderer.java
index 233f5c8..310c091 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ListFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesDialog.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesDialog.java
index f928790..9e5e1f5 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesDialog.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesDialog.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesPageRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesPageRenderer.java
index 10f7cb0..d543725 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesPageRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/PreferencesPageRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/RadioGroupFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/RadioGroupFieldEditorRenderer.java
index 9a4c83f..ce1458f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/RadioGroupFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/RadioGroupFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ScaleFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ScaleFieldEditorRenderer.java
index 1758e9f..cb8a21f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ScaleFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/ScaleFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/StringFieldEditorRenderer.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/StringFieldEditorRenderer.java
index 6ba794f..0f630a6 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/StringFieldEditorRenderer.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/StringFieldEditorRenderer.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/exception/ValidationFailedException.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/exception/ValidationFailedException.java
index e67dfdd..109ccb0 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/exception/ValidationFailedException.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/exception/ValidationFailedException.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/BasicImpExp.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/BasicImpExp.java
index 15e130a..ebeac13 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/BasicImpExp.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/BasicImpExp.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ExportPreferences.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ExportPreferences.java
index bc5dd93..2bdb9df 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ExportPreferences.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ExportPreferences.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ImportPreferences.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ImportPreferences.java
index 345d248..9f627be 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ImportPreferences.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/impexp/ImportPreferences.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProvider.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProvider.java
index 8be19a0..77f7f68 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProvider.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProvider.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProviderContextFunction.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProviderContextFunction.java
index 7e8df1d..5d73747 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProviderContextFunction.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/service/PreferenceProviderContextFunction.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/EmfHelper.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/EmfHelper.java
index 194a6a1..03bfd06 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/EmfHelper.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/EmfHelper.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/ModelHelper.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/ModelHelper.java
index 7f22af4..991c640 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/ModelHelper.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/ModelHelper.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/PrefHelper.java b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/PrefHelper.java
index 645c1d5..1c8caa5 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/PrefHelper.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.addon/src/org/eclipse/osbp/vaaclipse/ui/preferences/addon/internal/util/PrefHelper.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.html b/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.html
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.properties b/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.properties
index 91d8bfb..5d26df1 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.properties
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/build.properties b/org.eclipse.osbp.vaaclipse.ui.preferences.model/build.properties
index da0146c..ca4cf06 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/build.properties
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/build.properties
@@ -6,9 +6,9 @@
                plugin.xml,\
                plugin.properties,\
                license.html,\
-               epl-v10.html
+               epl-2.0.html
 jars.compile.order = .
 source.. = src/
 output.. = target/classes/
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/epl-2.0.html b/org.eclipse.osbp.vaaclipse.ui.preferences.model/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/epl-v10.html b/org.eclipse.osbp.vaaclipse.ui.preferences.model/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/license.html b/org.eclipse.osbp.vaaclipse.ui.preferences.model/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/license.html
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/pom.xml b/org.eclipse.osbp.vaaclipse.ui.preferences.model/pom.xml
index 7d626ba..8f6defe 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/internal/Activator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/internal/Activator.java
index 36a0cfa..4aad809 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/internal/Activator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/internal/Activator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldEditor.java
index 58e2979..7978b79 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldStyle.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldStyle.java
index 26081bc..87943e0 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldStyle.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/BooleanFieldStyle.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ComboFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ComboFieldEditor.java
index a44cb00..3af065f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ComboFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ComboFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/DirectoryFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/DirectoryFieldEditor.java
index 3f1495e..40be020 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/DirectoryFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/DirectoryFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/Entry.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/Entry.java
index e623a94..0d56fb3 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/Entry.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/Entry.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FieldEditor.java
index 0d80468..b4fd872 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FileFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FileFieldEditor.java
index 7face91..9fe9ccd 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FileFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/FileFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/IntegerFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/IntegerFieldEditor.java
index 5f835d4..6a2f1c7 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/IntegerFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/IntegerFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListCrud.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListCrud.java
index ebe9265..a7f0b96 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListCrud.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListCrud.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListEditor.java
index 643000b..5d5cb18 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFieldEditor.java
index afa23ce..84f96cb 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFold.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFold.java
index 51d4782..7e0b1fb 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFold.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ListFold.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesCategory.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesCategory.java
index 69e414e..983df35 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesCategory.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesCategory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesPage.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesPage.java
index 5b6736e..0792d15 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesPage.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/PreferencesPage.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/RadioGroupFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/RadioGroupFieldEditor.java
index ce79721..db7aa3f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/RadioGroupFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/RadioGroupFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ScaleFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ScaleFieldEditor.java
index 2b22d67..76e10fe 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ScaleFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/ScaleFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/StringFieldEditor.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/StringFieldEditor.java
index 29bc184..4385cf2 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/StringFieldEditor.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/StringFieldEditor.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/BooleanFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/BooleanFieldEditorImpl.java
index 02ea97c..cb95a2b 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/BooleanFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/BooleanFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ComboFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ComboFieldEditorImpl.java
index af3e420..f1de19f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ComboFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ComboFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/DirectoryFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/DirectoryFieldEditorImpl.java
index 8a55b93..672ee8e 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/DirectoryFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/DirectoryFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/EntryImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/EntryImpl.java
index a24c45e..14e9ab3 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/EntryImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/EntryImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FieldEditorImpl.java
index edf327d..49271e3 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FileFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FileFieldEditorImpl.java
index 4819ad3..dd284ab 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FileFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/FileFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/IntegerFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/IntegerFieldEditorImpl.java
index 75c3628..99fe4b6 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/IntegerFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/IntegerFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListEditorImpl.java
index def2517..d11740e 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFieldEditorImpl.java
index d6e3029..b5ca653 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFoldImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFoldImpl.java
index 2c45a1b..ae509df 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFoldImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ListFoldImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesCategoryImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesCategoryImpl.java
index 50c0363..f0d50ef 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesCategoryImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesCategoryImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesFactoryImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesFactoryImpl.java
index d8909a2..f9c7e55 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesFactoryImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesFactoryImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPackageImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPackageImpl.java
index 253d483..70c6633 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPackageImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPackageImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPageImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPageImpl.java
index f560a15..c3252bb 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPageImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/PreferencesPageImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/RadioGroupFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/RadioGroupFieldEditorImpl.java
index e04d1aa..1f1a95d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/RadioGroupFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/RadioGroupFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ScaleFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ScaleFieldEditorImpl.java
index 5b98eb5..3197cf9 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ScaleFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/ScaleFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/StringFieldEditorImpl.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/StringFieldEditorImpl.java
index f0dab7a..d1c3bdb 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/StringFieldEditorImpl.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/impl/StringFieldEditorImpl.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesFactory.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesFactory.java
index df68ed6..3d93e79 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesFactory.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesPackage.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesPackage.java
index db5cf11..037b57b 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesPackage.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/metadata/PreferencesPackage.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesAdapterFactory.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesAdapterFactory.java
index 0e8196d..9103b8d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesAdapterFactory.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesAdapterFactory.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesSwitch.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesSwitch.java
index b92a367..6ac5f68 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesSwitch.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/util/PreferencesSwitch.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/BooleanFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/BooleanFieldEditorValidator.java
index 4f3b8ff..afbe325 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/BooleanFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/BooleanFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ComboFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ComboFieldEditorValidator.java
index 0a67cd1..37828b0 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ComboFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ComboFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/DirectoryFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/DirectoryFieldEditorValidator.java
index ec6060e..b3ec1d3 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/DirectoryFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/DirectoryFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/EntryValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/EntryValidator.java
index e3dceb4..4e3995e 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/EntryValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/EntryValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FieldEditorValidator.java
index 59a0fff..232e9e7 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FileFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FileFieldEditorValidator.java
index 1ece9c7..22dcd3f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FileFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/FileFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/IntegerFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/IntegerFieldEditorValidator.java
index 9151793..0e1df3d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/IntegerFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/IntegerFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListCrudValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListCrudValidator.java
index e49b3b7..fb1e760 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListCrudValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListCrudValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListEditorValidator.java
index c5fedfa..3afe21f 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFieldEditorValidator.java
index 374244c..e422746 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFoldValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFoldValidator.java
index 6ec8d20..c59a116 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFoldValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ListFoldValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesCategoryValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesCategoryValidator.java
index 9099310..81bedc8 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesCategoryValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesCategoryValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesPageValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesPageValidator.java
index 8ebc98f..64fa3fc 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesPageValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/PreferencesPageValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/RadioGroupFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/RadioGroupFieldEditorValidator.java
index 0961d2d..741a40e 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/RadioGroupFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/RadioGroupFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ScaleFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ScaleFieldEditorValidator.java
index fdbd6a9..b9a252c 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ScaleFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/ScaleFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/StringFieldEditorValidator.java b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/StringFieldEditorValidator.java
index 5308b3b..45c0a6d 100644
--- a/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/StringFieldEditorValidator.java
+++ b/org.eclipse.osbp.vaaclipse.ui.preferences.model/src/org/eclipse/osbp/vaaclipse/ui/preferences/model/validation/StringFieldEditorValidator.java
@@ -1,9 +1,11 @@
 /**
  * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *         Florian Pirchner - Initial implementation
diff --git a/org.eclipse.osbp.vaaclipse.util/about.html b/org.eclipse.osbp.vaaclipse.util/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.util/about.html
+++ b/org.eclipse.osbp.vaaclipse.util/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.util/about.properties b/org.eclipse.osbp.vaaclipse.util/about.properties
index bdd9e29..ef9af6d 100644
--- a/org.eclipse.osbp.vaaclipse.util/about.properties
+++ b/org.eclipse.osbp.vaaclipse.util/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.util/build.properties b/org.eclipse.osbp.vaaclipse.util/build.properties
index ebe504b..be2a4d2 100644
--- a/org.eclipse.osbp.vaaclipse.util/build.properties
+++ b/org.eclipse.osbp.vaaclipse.util/build.properties
@@ -3,6 +3,6 @@
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
                license.html,\
-               epl-v10.html
+               epl-2.0.html
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.util/epl-2.0.html b/org.eclipse.osbp.vaaclipse.util/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.util/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.util/epl-v10.html b/org.eclipse.osbp.vaaclipse.util/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.util/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.util/license.html b/org.eclipse.osbp.vaaclipse.util/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.util/license.html
+++ b/org.eclipse.osbp.vaaclipse.util/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.util/pom.xml b/org.eclipse.osbp.vaaclipse.util/pom.xml
index abd85bc..62e18c7 100644
--- a/org.eclipse.osbp.vaaclipse.util/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.util/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/test/ConvertTest.java b/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/test/ConvertTest.java
index 8a0e66c..e5f14ed 100644
--- a/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/test/ConvertTest.java
+++ b/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/test/ConvertTest.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/util/Utils.java b/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/util/Utils.java
index e940ecb..20f17fd 100644
--- a/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/util/Utils.java
+++ b/org.eclipse.osbp.vaaclipse.util/src/org/eclipse/osbp/vaaclipse/util/Utils.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/about.html b/org.eclipse.osbp.vaaclipse.widgets/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/about.html
+++ b/org.eclipse.osbp.vaaclipse.widgets/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.widgets/about.properties b/org.eclipse.osbp.vaaclipse.widgets/about.properties
index 087da41..11b6d47 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/about.properties
+++ b/org.eclipse.osbp.vaaclipse.widgets/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.widgets/build.properties b/org.eclipse.osbp.vaaclipse.widgets/build.properties
index d1750a9..eee2d9d 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/build.properties
+++ b/org.eclipse.osbp.vaaclipse.widgets/build.properties
@@ -1,8 +1,8 @@
 source.. = src/
 output.. = target/classes/
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html,\
                .
 src.includes = about.properties,  about.mappings,  about.ini,  about.html,  license.html,\
-               epl-v10.html
+               epl-2.0.html
diff --git a/org.eclipse.osbp.vaaclipse.widgets/epl-2.0.html b/org.eclipse.osbp.vaaclipse.widgets/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.widgets/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.widgets/epl-v10.html b/org.eclipse.osbp.vaaclipse.widgets/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.widgets/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.widgets/license.html b/org.eclipse.osbp.vaaclipse.widgets/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/license.html
+++ b/org.eclipse.osbp.vaaclipse.widgets/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.widgets/pom.xml b/org.eclipse.osbp.vaaclipse.widgets/pom.xml
index c2344d8..9866e5e 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.widgets/pom.xml
@@ -2,8 +2,10 @@
 <!-- /******************************************************************************* 
 	* Copyright (c) 2012 Rushan R. Gilmullin and others. * All rights reserved. 
 	This program and the accompanying materials * are made available under the 
-	terms of the Eclipse Public License v1.0 * which accompanies this distribution, 
-	and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: 
+	terms of the Eclipse Public License 2.0  * which accompanies this distribution, 
+ * https://www.eclipse.org/legal/epl-2.0/ * * Contributors: 
+ * * * Contributors: 
+ * SPDX-License-Identifier: EPL-2.0 * * Contributors: 
 	* Rushan R. Gilmullin - initial API and implementation *******************************************************************************/ -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
@@ -24,18 +26,6 @@
 	</properties>
 
 	<dependencies>
-<!--	
-		<dependency>
-			<groupId>org.vaadin.addons</groupId>
-			<artifactId>dragdroplayouts</artifactId>
-			<version>1.3.2</version>
-		</dependency>
-		<dependency>
-			<groupId>org.vaadin.addon</groupId>
-			<artifactId>easyuploads</artifactId>
-			<version>7.4.2</version>
-		</dependency>
--->		
 		<dependency>
 			<groupId>com.vaadin</groupId>
 			<artifactId>vaadin-server</artifactId>
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/FastView.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/FastView.java
index c66cd2a..71bb959 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/FastView.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/FastView.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/StackWidget.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/StackWidget.java
index d211832..77c9dc5 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/StackWidget.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/StackWidget.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewConnector.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewConnector.java
index 27914e4..77f343e 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewConnector.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewConnector.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewState.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewState.java
index 4f45812..7ed1ffc 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewState.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/FastViewState.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/VFastView.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/VFastView.java
index 7dfb4e6..5c9be61 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/VFastView.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/fastview/VFastView.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/StackWidgetConnector.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/StackWidgetConnector.java
index a0d04d5..ec6b068 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/StackWidgetConnector.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/StackWidgetConnector.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidget.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidget.java
index acee73f..809f3f2 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidget.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidget.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidgetDropHandler.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidgetDropHandler.java
index 1bf2f5d..9544e05 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidgetDropHandler.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/client/ui/stackwidget/VStackWidgetDropHandler.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Bounds.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Bounds.java
index 271ecfa..fb6e69f 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Bounds.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Bounds.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Constants.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Constants.java
index 5e7080e..d3f9ca8 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Constants.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Constants.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeomUtils.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeomUtils.java
index 82269ad..d3b85c2 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeomUtils.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeomUtils.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeometryHelper.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeometryHelper.java
index cfe2c95..ae5b0cf 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeometryHelper.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/GeometryHelper.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Rectangle.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Rectangle.java
index b8707ec..6700a70 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Rectangle.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Rectangle.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Side.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Side.java
index d6bbc60..a36b4ee 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Side.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Side.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Vector.java b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Vector.java
index 0f52d3a..bbb1605 100644
--- a/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Vector.java
+++ b/org.eclipse.osbp.vaaclipse.widgets/src/org/eclipse/osbp/vaaclipse/widgets/common/Vector.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/about.html b/org.eclipse.osbp.vaaclipse.widgetset.default/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/about.html
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/about.properties b/org.eclipse.osbp.vaaclipse.widgetset.default/about.properties
index 665d2ce..e710939 100644
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/about.properties
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/build.properties b/org.eclipse.osbp.vaaclipse.widgetset.default/build.properties
index 2ebdb20..0bd1635 100644
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/build.properties
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/build.properties
@@ -5,7 +5,7 @@
                pom.xml,\
                src/,\
                build.properties,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/epl-2.0.html b/org.eclipse.osbp.vaaclipse.widgetset.default/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/epl-v10.html b/org.eclipse.osbp.vaaclipse.widgetset.default/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/license.html b/org.eclipse.osbp.vaaclipse.widgetset.default/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/license.html
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/pom.xml b/org.eclipse.osbp.vaaclipse.widgetset.default/pom.xml
index 8dba97e..6a5d306 100644
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/pom.xml
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/pom.xml
@@ -2,8 +2,10 @@
 <!-- /******************************************************************************* 
 	* Copyright (c) 2012 Rushan R. Gilmullin and others. * All rights reserved. 
 	This program and the accompanying materials * are made available under the 
-	terms of the Eclipse Public License v1.0 * which accompanies this distribution, 
-	and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: 
+	terms of the Eclipse Public License 2.0  * which accompanies this distribution, 
+ * https://www.eclipse.org/legal/epl-2.0/ * * Contributors: 
+ * * * Contributors: 
+ * SPDX-License-Identifier: EPL-2.0 * * Contributors: 
 	* Rushan R. Gilmullin - initial API and implementation *******************************************************************************/ -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
diff --git a/org.eclipse.osbp.vaaclipse.widgetset.default/src/org/eclipse/osbp/vaaclipse/widgetset/WidgetsetUI.java b/org.eclipse.osbp.vaaclipse.widgetset.default/src/org/eclipse/osbp/vaaclipse/widgetset/WidgetsetUI.java
index 56d72d6..70e1ec7 100644
--- a/org.eclipse.osbp.vaaclipse.widgetset.default/src/org/eclipse/osbp/vaaclipse/widgetset/WidgetsetUI.java
+++ b/org.eclipse.osbp.vaaclipse.widgetset.default/src/org/eclipse/osbp/vaaclipse/widgetset/WidgetsetUI.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaadin/about.html b/org.eclipse.osbp.vaadin/about.html
index 64c0598..e8b834d 100644
--- a/org.eclipse.osbp.vaadin/about.html
+++ b/org.eclipse.osbp.vaadin/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 1, 2016</p>	
+<p>November 30, 2017</p>	
 <h3>License</h3>
 
 <p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
 indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="https://www.eclipse.org/legal/epl-2.0">https://www.eclipse.org/legal/epl-2.0</a>.
 For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
 
 <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
diff --git a/org.eclipse.osbp.vaadin/about.properties b/org.eclipse.osbp.vaadin/about.properties
index fc6a85b..da026f4 100644
--- a/org.eclipse.osbp.vaadin/about.properties
+++ b/org.eclipse.osbp.vaadin/about.properties
@@ -1,9 +1,11 @@
 #
 # Copyright (c) 2012, 2016 - Loetz GmbH&Co.KG (Heidelberg)
 # All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Eclipse Public License v1.0
+# are made available under the terms of the Eclipse Public License 2.0 
 # which accompanies this distribution, and is available at
-# http://www.eclipse.org/legal/epl-v10.html
+# https://www.eclipse.org/legal/epl-2.0/
+#
+# SPDX-License-Identifier: EPL-2.0
 #
 # Contributors:
 #    Loetz GmbH&Co.KG - initial API and implementation
@@ -17,9 +19,11 @@
 featureText=\
 Copyright (c) 2012-2016 - Loetz GmbH&Co.KG \n\
 All rights reserved. This program and the accompanying materials\n\
-are made available under the terms of the Eclipse Public License v1.0\n\
+are made available under the terms of the Eclipse Public License 2.0 \n\
 which accompanies this distribution, and is available at\n\
-http://www.eclipse.org/legal/epl-v10.html\n\
+https://www.eclipse.org/legal/epl-2.0/\n\
+\n\
+SPDX-License-Identifier: EPL-2.0\n\
 \n\
 Contributors:\n\
     Loetz GmbH&Co.KG - implementation\n
diff --git a/org.eclipse.osbp.vaadin/build.properties b/org.eclipse.osbp.vaadin/build.properties
index a138bbd..48a7870 100644
--- a/org.eclipse.osbp.vaadin/build.properties
+++ b/org.eclipse.osbp.vaadin/build.properties
@@ -2,7 +2,7 @@
 output.. = target/classes/
 bin.includes = about.properties,  about.mappings,  about.ini,  about.html,  META-INF/,\
                .,\
-               epl-v10.html,\
+               epl-2.0.html,\
                license.html
-src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-v10.html,\
+src.includes = about.properties,  about.mappings,  about.ini,  about.html,  epl-2.0.html,\
                license.html
diff --git a/org.eclipse.osbp.vaadin/epl-2.0.html b/org.eclipse.osbp.vaadin/epl-2.0.html
new file mode 100644
index 0000000..637a181
--- /dev/null
+++ b/org.eclipse.osbp.vaadin/epl-2.0.html
@@ -0,0 +1,300 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Eclipse Public License - Version 2.0</title>
+    <style type="text/css">
+      body {
+        margin: 1.5em 3em;
+      }
+      h1{
+        font-size:1.5em;
+      }
+      h2{
+        font-size:1em;
+        margin-bottom:0.5em;
+        margin-top:1em;
+      }
+      p {
+        margin-top:  0.5em;
+        margin-bottom: 0.5em;
+      }
+      ul, ol{
+        list-style-type:none;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Eclipse Public License - v 2.0</h1>
+    <p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE (&ldquo;AGREEMENT&rdquo;). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT&#039;S ACCEPTANCE OF THIS AGREEMENT.
+    </p>
+    <h2 id="definitions">1. DEFINITIONS</h2>
+    <p>&ldquo;Contribution&rdquo; means:</p>
+    <ul>
+      <li>a) in the case of the initial Contributor, the initial content
+        Distributed under this Agreement, and
+      </li>
+      <li>
+        b) in the case of each subsequent Contributor:
+        <ul>
+          <li>i) changes to the Program, and</li>
+          <li>ii) additions to the Program;</li>
+        </ul>
+        where such changes and/or additions to the Program originate from
+        and are Distributed by that particular Contributor. A Contribution
+        &ldquo;originates&rdquo; from a Contributor if it was added to the Program by such
+        Contributor itself or anyone acting on such Contributor&#039;s behalf.
+        Contributions do not include changes or additions to the Program that
+        are not Modified Works.
+      </li>
+    </ul>
+    <p>&ldquo;Contributor&rdquo; means any person or entity that Distributes the Program.</p>
+    <p>&ldquo;Licensed Patents&rdquo; mean patent claims licensable by a Contributor which
+      are necessarily infringed by the use or sale of its Contribution alone
+      or when combined with the Program.
+    </p>
+    <p>&ldquo;Program&rdquo; means the Contributions Distributed in accordance with this
+      Agreement.
+    </p>
+    <p>&ldquo;Recipient&rdquo; means anyone who receives the Program under this Agreement
+      or any Secondary License (as applicable), including Contributors.
+    </p>
+    <p>&ldquo;Derivative Works&rdquo; shall mean any work, whether in Source Code or other
+      form, that is based on (or derived from) the Program and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+    </p>
+    <p>&ldquo;Modified Works&rdquo; shall mean any work in Source Code or other form that
+      results from an addition to, deletion from, or modification of the
+      contents of the Program, including, for purposes of clarity any new file
+      in Source Code form that contains any contents of the Program. Modified
+      Works shall not include works that contain only declarations, interfaces,
+      types, classes, structures, or files of the Program solely in each case
+      in order to link to, bind by name, or subclass the Program or Modified
+      Works thereof.
+    </p>
+    <p>&ldquo;Distribute&rdquo; means the acts of a) distributing or b) making available
+      in any manner that enables the transfer of a copy.
+    </p>
+    <p>&ldquo;Source Code&rdquo; means the form of a Program preferred for making
+      modifications, including but not limited to software source code,
+      documentation source, and configuration files.
+    </p>
+    <p>&ldquo;Secondary License&rdquo; means either the GNU General Public License,
+      Version 2.0, or any later versions of that license, including any
+      exceptions or additional permissions as identified by the initial
+      Contributor.
+    </p>
+    <h2 id="grant-of-rights">2. GRANT OF RIGHTS</h2>
+    <ul>
+      <li>a) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free copyright
+        license to reproduce, prepare Derivative Works of, publicly display,
+        publicly perform, Distribute and sublicense the Contribution of such
+        Contributor, if any, and such Derivative Works.
+      </li>
+      <li>b) Subject to the terms of this Agreement, each Contributor hereby
+        grants Recipient a non-exclusive, worldwide, royalty-free patent
+        license under Licensed Patents to make, use, sell, offer to sell,
+        import and otherwise transfer the Contribution of such Contributor,
+        if any, in Source Code or other form. This patent license shall
+        apply to the combination of the Contribution and the Program if,
+        at the time the Contribution is added by the Contributor, such
+        addition of the Contribution causes such combination to be covered
+        by the Licensed Patents. The patent license shall not apply to any
+        other combinations which include the Contribution. No hardware per
+        se is licensed hereunder.
+      </li>
+      <li>c) Recipient understands that although each Contributor grants the
+        licenses to its Contributions set forth herein, no assurances are
+        provided by any Contributor that the Program does not infringe the
+        patent or other intellectual property rights of any other entity.
+        Each Contributor disclaims any liability to Recipient for claims
+        brought by any other entity based on infringement of intellectual
+        property rights or otherwise. As a condition to exercising the rights
+        and licenses granted hereunder, each Recipient hereby assumes sole
+        responsibility to secure any other intellectual property rights needed,
+        if any. For example, if a third party patent license is required to
+        allow Recipient to Distribute the Program, it is Recipient&#039;s
+        responsibility to acquire that license before distributing the Program.
+      </li>
+      <li>d) Each Contributor represents that to its knowledge it has sufficient
+        copyright rights in its Contribution, if any, to grant the copyright
+        license set forth in this Agreement.
+      </li>
+      <li>e) Notwithstanding the terms of any Secondary License, no Contributor
+        makes additional grants to any Recipient (other than those set forth
+        in this Agreement) as a result of such Recipient&#039;s receipt of the
+        Program under the terms of a Secondary License (if permitted under
+        the terms of Section 3).
+      </li>
+    </ul>
+    <h2 id="requirements">3. REQUIREMENTS</h2>
+    <p>3.1 If a Contributor Distributes the Program in any form, then:</p>
+    <ul>
+      <li>a) the Program must also be made available as Source Code, in
+        accordance with section 3.2, and the Contributor must accompany
+        the Program with a statement that the Source Code for the Program
+        is available under this Agreement, and informs Recipients how to
+        obtain it in a reasonable manner on or through a medium customarily
+        used for software exchange; and
+      </li>
+      <li>
+        b) the Contributor may Distribute the Program under a license
+        different than this Agreement, provided that such license:
+        <ul>
+          <li>i) effectively disclaims on behalf of all other Contributors all
+            warranties and conditions, express and implied, including warranties
+            or conditions of title and non-infringement, and implied warranties
+            or conditions of merchantability and fitness for a particular purpose;
+          </li>
+          <li>ii) effectively excludes on behalf of all other Contributors all
+            liability for damages, including direct, indirect, special, incidental
+            and consequential damages, such as lost profits;
+          </li>
+          <li>iii) does not attempt to limit or alter the recipients&#039; rights in the
+            Source Code under section 3.2; and
+          </li>
+          <li>iv) requires any subsequent distribution of the Program by any party
+            to be under a license that satisfies the requirements of this section 3.
+          </li>
+        </ul>
+      </li>
+    </ul>
+    <p>3.2 When the Program is Distributed as Source Code:</p>
+    <ul>
+      <li>a) it must be made available under this Agreement, or if the Program (i)
+        is combined with other material in a separate file or files made available
+        under a Secondary License, and (ii) the initial Contributor attached to
+        the Source Code the notice described in Exhibit A of this Agreement,
+        then the Program may be made available under the terms of such
+        Secondary Licenses, and
+      </li>
+      <li>b) a copy of this Agreement must be included with each copy of the Program.</li>
+    </ul>
+    <p>3.3 Contributors may not remove or alter any copyright, patent, trademark,
+      attribution notices, disclaimers of warranty, or limitations of liability
+      (&lsquo;notices&rsquo;) contained within the Program from any copy of the Program which
+      they Distribute, provided that Contributors may add their own appropriate
+      notices.
+    </p>
+    <h2 id="commercial-distribution">4. COMMERCIAL DISTRIBUTION</h2>
+    <p>Commercial distributors of software may accept certain responsibilities
+      with respect to end users, business partners and the like. While this
+      license is intended to facilitate the commercial use of the Program, the
+      Contributor who includes the Program in a commercial product offering should
+      do so in a manner which does not create potential liability for other
+      Contributors. Therefore, if a Contributor includes the Program in a
+      commercial product offering, such Contributor (&ldquo;Commercial Contributor&rdquo;)
+      hereby agrees to defend and indemnify every other Contributor
+      (&ldquo;Indemnified Contributor&rdquo;) against any losses, damages and costs
+      (collectively &ldquo;Losses&rdquo;) arising from claims, lawsuits and other legal actions
+      brought by a third party against the Indemnified Contributor to the extent
+      caused by the acts or omissions of such Commercial Contributor in connection
+      with its distribution of the Program in a commercial product offering.
+      The obligations in this section do not apply to any claims or Losses relating
+      to any actual or alleged intellectual property infringement. In order to
+      qualify, an Indemnified Contributor must: a) promptly notify the
+      Commercial Contributor in writing of such claim, and b) allow the Commercial
+      Contributor to control, and cooperate with the Commercial Contributor in,
+      the defense and any related settlement negotiations. The Indemnified
+      Contributor may participate in any such claim at its own expense.
+    </p>
+    <p>For example, a Contributor might include the Program
+      in a commercial product offering, Product X. That Contributor is then a
+      Commercial Contributor. If that Commercial Contributor then makes performance
+      claims, or offers warranties related to Product X, those performance claims
+      and warranties are such Commercial Contributor&#039;s responsibility alone.
+      Under this section, the Commercial Contributor would have to defend claims
+      against the other Contributors related to those performance claims and
+      warranties, and if a court requires any other Contributor to pay any damages
+      as a result, the Commercial Contributor must pay those damages.
+    </p>
+    <h2 id="warranty">5. NO WARRANTY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN &ldquo;AS IS&rdquo; BASIS, WITHOUT
+      WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+      WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+      MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+      solely responsible for determining the appropriateness of using and
+      distributing the Program and assumes all risks associated with its
+      exercise of rights under this Agreement, including but not limited to the
+      risks and costs of program errors, compliance with applicable laws, damage
+      to or loss of data, programs or equipment, and unavailability or
+      interruption of operations.
+    </p>
+    <h2 id="disclaimer">6. DISCLAIMER OF LIABILITY</h2>
+    <p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED
+      BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY
+      LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+      OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+      HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+      LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+      OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+      GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    </p>
+    <h2 id="general">7. GENERAL</h2>
+    <p>If any provision of this Agreement is invalid or unenforceable under
+      applicable law, it shall not affect the validity or enforceability of the
+      remainder of the terms of this Agreement, and without further action by the
+      parties hereto, such provision shall be reformed to the minimum extent
+      necessary to make such provision valid and enforceable.
+    </p>
+    <p>If Recipient institutes patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+      (excluding combinations of the Program with other software or hardware)
+      infringes such Recipient&#039;s patent(s), then such Recipient&#039;s rights granted
+      under Section 2(b) shall terminate as of the date such litigation is filed.
+    </p>
+    <p>All Recipient&#039;s rights under this Agreement shall terminate if it fails to
+      comply with any of the material terms or conditions of this Agreement and
+      does not cure such failure in a reasonable period of time after becoming
+      aware of such noncompliance. If all Recipient&#039;s rights under this Agreement
+      terminate, Recipient agrees to cease use and distribution of the Program
+      as soon as reasonably practicable. However, Recipient&#039;s obligations under
+      this Agreement and any licenses granted by Recipient relating to the
+      Program shall continue and survive.
+    </p>
+    <p>Everyone is permitted to copy and distribute copies of this Agreement,
+      but in order to avoid inconsistency the Agreement is copyrighted and may
+      only be modified in the following manner. The Agreement Steward reserves
+      the right to publish new versions (including revisions) of this Agreement
+      from time to time. No one other than the Agreement Steward has the right
+      to modify this Agreement. The Eclipse Foundation is the initial Agreement
+      Steward. The Eclipse Foundation may assign the responsibility to serve as
+      the Agreement Steward to a suitable separate entity. Each new version of
+      the Agreement will be given a distinguishing version number. The Program
+      (including Contributions) may always be Distributed subject to the version
+      of the Agreement under which it was received. In addition, after a new
+      version of the Agreement is published, Contributor may elect to Distribute
+      the Program (including its Contributions) under the new version.
+    </p>
+    <p>Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+      receives no rights or licenses to the intellectual property of any
+      Contributor under this Agreement, whether expressly, by implication,
+      estoppel or otherwise. All rights in the Program not expressly granted
+      under this Agreement are reserved. Nothing in this Agreement is intended
+      to be enforceable by any entity that is not a Contributor or Recipient.
+      No third-party beneficiary rights are created under this Agreement.
+    </p>
+    <h2 id="exhibit-a">Exhibit A &ndash; Form of Secondary Licenses Notice</h2>
+    <p>&ldquo;This Source Code may also be made available under the following 
+    	Secondary Licenses when the conditions for such availability set forth 
+    	in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+    	version(s), and exceptions or additional permissions here}.&rdquo;
+    </p>
+    <blockquote>
+      <p>Simply including a copy of this Agreement, including this Exhibit A
+        is not sufficient to license the Source Code under Secondary Licenses.
+      </p>
+      <p>If it is not possible or desirable to put the notice in a particular file,
+        then You may include the notice in a location (such as a LICENSE file in a
+        relevant directory) where a recipient would be likely to look for
+        such a notice.
+      </p>
+      <p>You may add additional accurate notices of copyright ownership.</p>
+    </blockquote>
+  </body>
+</html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin/epl-v10.html b/org.eclipse.osbp.vaadin/epl-v10.html
deleted file mode 100644
index b398acc..0000000
--- a/org.eclipse.osbp.vaadin/epl-v10.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Eclipse Public License - Version 1.0</title>
-<style type="text/css">
-  body {
-    size: 8.5in 11.0in;
-    margin: 0.25in 0.5in 0.25in 0.5in;
-    tab-interval: 0.5in;
-    }
-  p {  	
-    margin-left: auto;
-    margin-top:  0.5em;
-    margin-bottom: 0.5em;
-    }
-  p.list {
-  	margin-left: 0.5in;
-    margin-top:  0.05em;
-    margin-bottom: 0.05em;
-    }
-  </style>
-
-</head>
-
-<body lang="EN-US">
-
-<h2>Eclipse Public License - v 1.0</h2>
-
-<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
-PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>"Contribution" means:</p>
-
-<p class="list">a) in the case of the initial Contributor, the initial
-code and documentation distributed under this Agreement, and</p>
-<p class="list">b) in the case of each subsequent Contributor:</p>
-<p class="list">i) changes to the Program, and</p>
-<p class="list">ii) additions to the Program;</p>
-<p class="list">where such changes and/or additions to the Program
-originate from and are distributed by that particular Contributor. A
-Contribution 'originates' from a Contributor if it was added to the
-Program by such Contributor itself or anyone acting on such
-Contributor's behalf. Contributions do not include additions to the
-Program which: (i) are separate modules of software distributed in
-conjunction with the Program under their own license agreement, and (ii)
-are not derivative works of the Program.</p>
-
-<p>"Contributor" means any person or entity that distributes
-the Program.</p>
-
-<p>"Licensed Patents" mean patent claims licensable by a
-Contributor which are necessarily infringed by the use or sale of its
-Contribution alone or when combined with the Program.</p>
-
-<p>"Program" means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>"Recipient" means anyone who receives the Program under
-this Agreement, including all Contributors.</p>
-
-<p><b>2. GRANT OF RIGHTS</b></p>
-
-<p class="list">a) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free copyright license to reproduce, prepare derivative works
-of, publicly display, publicly perform, distribute and sublicense the
-Contribution of such Contributor, if any, and such derivative works, in
-source code and object code form.</p>
-
-<p class="list">b) Subject to the terms of this Agreement, each
-Contributor hereby grants Recipient a non-exclusive, worldwide,
-royalty-free patent license under Licensed Patents to make, use, sell,
-offer to sell, import and otherwise transfer the Contribution of such
-Contributor, if any, in source code and object code form. This patent
-license shall apply to the combination of the Contribution and the
-Program if, at the time the Contribution is added by the Contributor,
-such addition of the Contribution causes such combination to be covered
-by the Licensed Patents. The patent license shall not apply to any other
-combinations which include the Contribution. No hardware per se is
-licensed hereunder.</p>
-
-<p class="list">c) Recipient understands that although each Contributor
-grants the licenses to its Contributions set forth herein, no assurances
-are provided by any Contributor that the Program does not infringe the
-patent or other intellectual property rights of any other entity. Each
-Contributor disclaims any liability to Recipient for claims brought by
-any other entity based on infringement of intellectual property rights
-or otherwise. As a condition to exercising the rights and licenses
-granted hereunder, each Recipient hereby assumes sole responsibility to
-secure any other intellectual property rights needed, if any. For
-example, if a third party patent license is required to allow Recipient
-to distribute the Program, it is Recipient's responsibility to acquire
-that license before distributing the Program.</p>
-
-<p class="list">d) Each Contributor represents that to its knowledge it
-has sufficient copyright rights in its Contribution, if any, to grant
-the copyright license set forth in this Agreement.</p>
-
-<p><b>3. REQUIREMENTS</b></p>
-
-<p>A Contributor may choose to distribute the Program in object code
-form under its own license agreement, provided that:</p>
-
-<p class="list">a) it complies with the terms and conditions of this
-Agreement; and</p>
-
-<p class="list">b) its license agreement:</p>
-
-<p class="list">i) effectively disclaims on behalf of all Contributors
-all warranties and conditions, express and implied, including warranties
-or conditions of title and non-infringement, and implied warranties or
-conditions of merchantability and fitness for a particular purpose;</p>
-
-<p class="list">ii) effectively excludes on behalf of all Contributors
-all liability for damages, including direct, indirect, special,
-incidental and consequential damages, such as lost profits;</p>
-
-<p class="list">iii) states that any provisions which differ from this
-Agreement are offered by that Contributor alone and not by any other
-party; and</p>
-
-<p class="list">iv) states that source code for the Program is available
-from such Contributor, and informs licensees how to obtain it in a
-reasonable manner on or through a medium customarily used for software
-exchange.</p>
-
-<p>When the Program is made available in source code form:</p>
-
-<p class="list">a) it must be made available under this Agreement; and</p>
-
-<p class="list">b) a copy of this Agreement must be included with each
-copy of the Program.</p>
-
-<p>Contributors may not remove or alter any copyright notices contained
-within the Program.</p>
-
-<p>Each Contributor must identify itself as the originator of its
-Contribution, if any, in a manner that reasonably allows subsequent
-Recipients to identify the originator of the Contribution.</p>
-
-<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
-
-<p>Commercial distributors of software may accept certain
-responsibilities with respect to end users, business partners and the
-like. While this license is intended to facilitate the commercial use of
-the Program, the Contributor who includes the Program in a commercial
-product offering should do so in a manner which does not create
-potential liability for other Contributors. Therefore, if a Contributor
-includes the Program in a commercial product offering, such Contributor
-("Commercial Contributor") hereby agrees to defend and
-indemnify every other Contributor ("Indemnified Contributor")
-against any losses, damages and costs (collectively "Losses")
-arising from claims, lawsuits and other legal actions brought by a third
-party against the Indemnified Contributor to the extent caused by the
-acts or omissions of such Commercial Contributor in connection with its
-distribution of the Program in a commercial product offering. The
-obligations in this section do not apply to any claims or Losses
-relating to any actual or alleged intellectual property infringement. In
-order to qualify, an Indemnified Contributor must: a) promptly notify
-the Commercial Contributor in writing of such claim, and b) allow the
-Commercial Contributor to control, and cooperate with the Commercial
-Contributor in, the defense and any related settlement negotiations. The
-Indemnified Contributor may participate in any such claim at its own
-expense.</p>
-
-<p>For example, a Contributor might include the Program in a commercial
-product offering, Product X. That Contributor is then a Commercial
-Contributor. If that Commercial Contributor then makes performance
-claims, or offers warranties related to Product X, those performance
-claims and warranties are such Commercial Contributor's responsibility
-alone. Under this section, the Commercial Contributor would have to
-defend claims against the other Contributors related to those
-performance claims and warranties, and if a court requires any other
-Contributor to pay any damages as a result, the Commercial Contributor
-must pay those damages.</p>
-
-<p><b>5. NO WARRANTY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
-PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
-OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
-ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
-OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
-responsible for determining the appropriateness of using and
-distributing the Program and assumes all risks associated with its
-exercise of rights under this Agreement , including but not limited to
-the risks and costs of program errors, compliance with applicable laws,
-damage to or loss of data, programs or equipment, and unavailability or
-interruption of operations.</p>
-
-<p><b>6. DISCLAIMER OF LIABILITY</b></p>
-
-<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
-NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
-WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
-DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
-HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
-
-<p><b>7. GENERAL</b></p>
-
-<p>If any provision of this Agreement is invalid or unenforceable under
-applicable law, it shall not affect the validity or enforceability of
-the remainder of the terms of this Agreement, and without further action
-by the parties hereto, such provision shall be reformed to the minimum
-extent necessary to make such provision valid and enforceable.</p>
-
-<p>If Recipient institutes patent litigation against any entity
-(including a cross-claim or counterclaim in a lawsuit) alleging that the
-Program itself (excluding combinations of the Program with other
-software or hardware) infringes such Recipient's patent(s), then such
-Recipient's rights granted under Section 2(b) shall terminate as of the
-date such litigation is filed.</p>
-
-<p>All Recipient's rights under this Agreement shall terminate if it
-fails to comply with any of the material terms or conditions of this
-Agreement and does not cure such failure in a reasonable period of time
-after becoming aware of such noncompliance. If all Recipient's rights
-under this Agreement terminate, Recipient agrees to cease use and
-distribution of the Program as soon as reasonably practicable. However,
-Recipient's obligations under this Agreement and any licenses granted by
-Recipient relating to the Program shall continue and survive.</p>
-
-<p>Everyone is permitted to copy and distribute copies of this
-Agreement, but in order to avoid inconsistency the Agreement is
-copyrighted and may only be modified in the following manner. The
-Agreement Steward reserves the right to publish new versions (including
-revisions) of this Agreement from time to time. No one other than the
-Agreement Steward has the right to modify this Agreement. The Eclipse
-Foundation is the initial Agreement Steward. The Eclipse Foundation may
-assign the responsibility to serve as the Agreement Steward to a
-suitable separate entity. Each new version of the Agreement will be
-given a distinguishing version number. The Program (including
-Contributions) may always be distributed subject to the version of the
-Agreement under which it was received. In addition, after a new version
-of the Agreement is published, Contributor may elect to distribute the
-Program (including its Contributions) under the new version. Except as
-expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
-rights or licenses to the intellectual property of any Contributor under
-this Agreement, whether expressly, by implication, estoppel or
-otherwise. All rights in the Program not expressly granted under this
-Agreement are reserved.</p>
-
-<p>This Agreement is governed by the laws of the State of New York and
-the intellectual property laws of the United States of America. No party
-to this Agreement will bring a legal action under this Agreement more
-than one year after the cause of action arose. Each party waives its
-rights to a jury trial in any resulting litigation.</p>
-
-
-
-</body></html>
\ No newline at end of file
diff --git a/org.eclipse.osbp.vaadin/license.html b/org.eclipse.osbp.vaadin/license.html
index 6e579a5..008b801 100644
--- a/org.eclipse.osbp.vaadin/license.html
+++ b/org.eclipse.osbp.vaadin/license.html
@@ -1,164 +1,189 @@
-<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml"><head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
 <title>Eclipse Foundation Software User Agreement</title>
 </head>
 
 <body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+	<h2>Eclipse Foundation Software User Agreement</h2>
+	<p>November 22, 2017</p>
 
-<h3>Usage Of Content</h3>
+	<h3>Usage Of Content</h3>
 
-<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
-   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
-   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
-   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
-   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
-   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+	<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION,
+		INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+		(COLLECTIVELY &quot;CONTENT&quot;). USE OF THE CONTENT IS GOVERNED BY
+		THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+		CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE CONTENT IS
+		GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY
+		APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED
+		BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS
+		AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE
+		AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT
+		USE THE CONTENT.</p>
 
-<h3>Applicable Licenses</h3>
+	<h3>Applicable Licenses</h3>
 
-<p>Unless otherwise indicated, all Content made available by the Eclipse
- Foundation is provided to you under the terms and conditions of the 
-Eclipse Public License Version 1.0
-   ("EPL").  A copy of the EPL is provided with this Content and is also
- available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-   For purposes of the EPL, "Program" will mean the Content.</p>
+	<p>
+		Unless otherwise indicated, all Content made available by the Eclipse
+		Foundation is provided to you under the terms and conditions of the
+		Eclipse Public License Version 2.0 (&quot;EPL&quot;). A copy of the
+		EPL is provided with this Content and is also available at <a
+			href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
+		For purposes of the EPL, &quot;Program&quot; will mean the Content.
+	</p>
 
-<p>Content includes, but is not limited to, source code, object code, 
-documentation and other files maintained in the Eclipse Foundation 
-source code
-   repository ("Repository") in software modules ("Modules") and made 
-available as downloadable archives ("Downloads").</p>
+	<p>Content includes, but is not limited to, source code, object
+		code, documentation and other files maintained in the Eclipse
+		Foundation source code repository (&quot;Repository&quot;) in software
+		modules (&quot;Modules&quot;) and made available as downloadable
+		archives (&quot;Downloads&quot;).</p>
 
-<ul>
-       <li>Content may be structured and packaged into modules to 
-facilitate delivering, extending, and upgrading the Content.  Typical 
-modules may include plug-ins ("Plug-ins"), plug-in fragments 
-("Fragments"), and features ("Features").</li>
-       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
-       <li>A Feature is a bundle of one or more Plug-ins and/or 
-Fragments and associated material.  Each Feature may be packaged as a 
-sub-directory in a directory named "features".  Within a Feature, files 
-named "feature.xml" may contain a list of the names and version numbers 
-of the Plug-ins
-      and/or Fragments associated with that Feature.</li>
-       <li>Features may also include other Features ("Included 
-Features"). Within a Feature, files named "feature.xml" may contain a 
-list of the names and version numbers of Included Features.</li>
-</ul>
+	<ul>
+		<li>Content may be structured and packaged into modules to
+			facilitate delivering, extending, and upgrading the Content. Typical
+			modules may include plug-ins (&quot;Plug-ins&quot;), plug-in
+			fragments (&quot;Fragments&quot;), and features
+			(&quot;Features&quot;).</li>
+		<li>Each Plug-in or Fragment may be packaged as a sub-directory
+			or JAR (Java&trade; ARchive) in a directory named
+			&quot;plugins&quot;.</li>
+		<li>A Feature is a bundle of one or more Plug-ins and/or
+			Fragments and associated material. Each Feature may be packaged as a
+			sub-directory in a directory named &quot;features&quot;. Within a
+			Feature, files named &quot;feature.xml&quot; may contain a list of
+			the names and version numbers of the Plug-ins and/or Fragments
+			associated with that Feature.</li>
+		<li>Features may also include other Features (&quot;Included
+			Features&quot;). Within a Feature, files named
+			&quot;feature.xml&quot; may contain a list of the names and version
+			numbers of Included Features.</li>
+	</ul>
 
-<p>The terms and conditions governing Plug-ins and Fragments should be 
-contained in files named "about.html" ("Abouts"). The terms and 
-conditions governing Features and
-Included Features should be contained in files named "license.html" 
-("Feature Licenses").  Abouts and Feature Licenses may be located in any
- directory of a Download or Module
-including, but not limited to the following locations:</p>
+	<p>The terms and conditions governing Plug-ins and Fragments should
+		be contained in files named &quot;about.html&quot;
+		(&quot;Abouts&quot;). The terms and conditions governing Features and
+		Included Features should be contained in files named
+		&quot;license.html&quot; (&quot;Feature Licenses&quot;). Abouts and
+		Feature Licenses may be located in any directory of a Download or
+		Module including, but not limited to the following locations:</p>
 
-<ul>
-       <li>The top-level (root) directory</li>
-       <li>Plug-in and Fragment directories</li>
-       <li>Inside Plug-ins and Fragments packaged as JARs</li>
-       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
-       <li>Feature directories</li>
-</ul>
+	<ul>
+		<li>The top-level (root) directory</li>
+		<li>Plug-in and Fragment directories</li>
+		<li>Inside Plug-ins and Fragments packaged as JARs</li>
+		<li>Sub-directories of the directory named &quot;src&quot; of
+			certain Plug-ins</li>
+		<li>Feature directories</li>
+	</ul>
 
-<p>Note: if a Feature made available by the Eclipse Foundation is 
-installed using the Provisioning Technology (as defined below), you must
- agree to a license ("Feature Update License") during the
-installation process.  If the Feature contains Included Features, the 
-Feature Update License should either provide you with the terms and 
-conditions governing the Included Features or
-inform you where you can locate them.  Feature Update Licenses may be 
-found in the "license" property of files named "feature.properties" 
-found within a Feature.
-Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
-terms and conditions (or references to such terms and conditions) that 
-govern your use of the associated Content in
-that directory.</p>
+	<p>Note: if a Feature made available by the Eclipse Foundation is
+		installed using the Provisioning Technology (as defined below), you
+		must agree to a license (&quot;Feature Update License&quot;) during
+		the installation process. If the Feature contains Included Features,
+		the Feature Update License should either provide you with the terms
+		and conditions governing the Included Features or inform you where you
+		can locate them. Feature Update Licenses may be found in the
+		&quot;license&quot; property of files named
+		&quot;feature.properties&quot; found within a Feature. Such Abouts,
+		Feature Licenses, and Feature Update Licenses contain the terms and
+		conditions (or references to such terms and conditions) that govern
+		your use of the associated Content in that directory.</p>
 
-<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
-TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
-  SOME OF THESE
-OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+	<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY
+		REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND
+		CONDITIONS. SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT
+		ARE NOT LIMITED TO):</p>
 
-<ul>
-       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
-       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
-       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
-       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
-       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
-       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
-</ul>
+	<ul>
+		<li>Eclipse Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>)
+		</li>
+		<li>Eclipse Distribution License Version 1.0 (available at <a
+			href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)
+		</li>
+		<li>Common Public License Version 1.0 (available at <a
+			href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)
+		</li>
+		<li>Apache Software License 1.1 (available at <a
+			href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)
+		</li>
+		<li>Apache Software License 2.0 (available at <a
+			href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)
+		</li>
+		<li>Mozilla Public License Version 1.1 (available at <a
+			href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)
+		</li>
+	</ul>
 
-<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
-CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
-or Feature Update License is provided, please
-contact the Eclipse Foundation to determine what terms and conditions 
-govern that particular Content.</p>
+	<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND
+		CONDITIONS PRIOR TO USE OF THE CONTENT. If no About, Feature License,
+		or Feature Update License is provided, please contact the Eclipse
+		Foundation to determine what terms and conditions govern that
+		particular Content.</p>
 
 
-<h3>Use of Provisioning Technology</h3>
+	<h3>Use of Provisioning Technology</h3>
 
-<p>The Eclipse Foundation makes available provisioning software, 
-examples of which include, but are not limited to, p2 and the Eclipse
-   Update Manager ("Provisioning Technology") for the purpose of 
-allowing users to install software, documentation, information and/or
-   other materials (collectively "Installable Software"). This 
-capability is provided with the intent of allowing such users to
-   install, extend and update Eclipse-based products. Information about 
-packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
-   ("Specification").</p>
+	<p>
+		The Eclipse Foundation makes available provisioning software, examples
+		of which include, but are not limited to, p2 and the Eclipse Update
+		Manager (&quot;Provisioning Technology&quot;) for the purpose of
+		allowing users to install software, documentation, information and/or
+		other materials (collectively &quot;Installable Software&quot;). This
+		capability is provided with the intent of allowing such users to
+		install, extend and update Eclipse-based products. Information about
+		packaging Installable Software is available at <a
+			href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+		(&quot;Specification&quot;).
+	</p>
 
-<p>You may use Provisioning Technology to allow other parties to install
- Installable Software. You shall be responsible for enabling the
-   applicable license agreements relating to the Installable Software to
- be presented to, and accepted by, the users of the Provisioning 
-Technology
-   in accordance with the Specification. By using Provisioning 
-Technology in such a manner and making it available in accordance with 
-the
-   Specification, you further acknowledge your agreement to, and the 
-acquisition of all necessary rights to permit the following:</p>
+	<p>You may use Provisioning Technology to allow other parties to
+		install Installable Software. You shall be responsible for enabling
+		the applicable license agreements relating to the Installable Software
+		to be presented to, and accepted by, the users of the Provisioning
+		Technology in accordance with the Specification. By using Provisioning
+		Technology in such a manner and making it available in accordance with
+		the Specification, you further acknowledge your agreement to, and the
+		acquisition of all necessary rights to permit the following:</p>
 
-<ol>
-       <li>A series of actions may occur ("Provisioning Process") in 
-which a user may execute the Provisioning Technology
-       on a machine ("Target Machine") with the intent of installing, 
-extending or updating the functionality of an Eclipse-based
-       product.</li>
-       <li>During the Provisioning Process, the Provisioning Technology 
-may cause third party Installable Software or a portion thereof to be
-       accessed and copied to the Target Machine.</li>
-       <li>Pursuant to the Specification, you will provide to the user 
-the terms and conditions that govern the use of the Installable
-       Software ("Installable Software Agreement") and such Installable 
-Software Agreement shall be accessed from the Target
-       Machine in accordance with the Specification. Such Installable 
-Software Agreement must inform the user of the terms and conditions that
- govern
-       the Installable Software and must solicit acceptance by the end 
-user in the manner prescribed in such Installable Software Agreement. 
-Upon such
-       indication of agreement by the user, the provisioning Technology 
-will complete installation of the Installable Software.</li>
-</ol>
+	<ol>
+		<li>A series of actions may occur (&quot;Provisioning
+			Process&quot;) in which a user may execute the Provisioning
+			Technology on a machine (&quot;Target Machine&quot;) with the intent
+			of installing, extending or updating the functionality of an
+			Eclipse-based product.</li>
+		<li>During the Provisioning Process, the Provisioning Technology
+			may cause third party Installable Software or a portion thereof to be
+			accessed and copied to the Target Machine.</li>
+		<li>Pursuant to the Specification, you will provide to the user
+			the terms and conditions that govern the use of the Installable
+			Software (&quot;Installable Software Agreement&quot;) and such
+			Installable Software Agreement shall be accessed from the Target
+			Machine in accordance with the Specification. Such Installable
+			Software Agreement must inform the user of the terms and conditions
+			that govern the Installable Software and must solicit acceptance by
+			the end user in the manner prescribed in such Installable Software
+			Agreement. Upon such indication of agreement by the user, the
+			provisioning Technology will complete installation of the Installable
+			Software.</li>
+	</ol>
 
-<h3>Cryptography</h3>
+	<h3>Cryptography</h3>
 
-<p>Content may contain encryption software. The country in which you are
- currently may have restrictions on the import, possession, and use, 
-and/or re-export to
-   another country, of encryption software. BEFORE using any encryption 
-software, please check the country's laws, regulations and policies 
-concerning the import,
-   possession, or use, and re-export of encryption software, to see if 
-this is permitted.</p>
+	<p>Content may contain encryption software. The country in which
+		you are currently may have restrictions on the import, possession, and
+		use, and/or re-export to another country, of encryption software.
+		BEFORE using any encryption software, please check the country's laws,
+		regulations and policies concerning the import, possession, or use,
+		and re-export of encryption software, to see if this is permitted.</p>
 
-<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
-
-
-</body></html>
\ No newline at end of file
+	<p>
+		<small>Java and all Java-based trademarks are trademarks of
+			Oracle Corporation in the United States, other countries, or both.</small>
+	</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.vaadin/pom.xml b/org.eclipse.osbp.vaadin/pom.xml
index 407c03d..65b7e95 100644
--- a/org.eclipse.osbp.vaadin/pom.xml
+++ b/org.eclipse.osbp.vaadin/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/org.eclipse.osbp.vaadin/src/org/eclipse/osbp/vaadin/optiondialog/OptionDialog.java b/org.eclipse.osbp.vaadin/src/org/eclipse/osbp/vaadin/optiondialog/OptionDialog.java
index 55d36d0..a732944 100644
--- a/org.eclipse.osbp.vaadin/src/org/eclipse/osbp/vaadin/optiondialog/OptionDialog.java
+++ b/org.eclipse.osbp.vaadin/src/org/eclipse/osbp/vaadin/optiondialog/OptionDialog.java
@@ -1,9 +1,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
diff --git a/pom.xml b/pom.xml
index c06ed4c..32204c7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -3,9 +3,11 @@
 /*******************************************************************************
  * Copyright (c) 2012 Rushan R. Gilmullin and others.
  * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
+ * are made available under the terms of the Eclipse Public License 2.0 
  * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
  *     Rushan R. Gilmullin - initial API and implementation
