diff --git a/examples/org.eclipse.graphiti.doc/about.html b/examples/org.eclipse.graphiti.doc/about.html
index d690ef4..38cecbb 100644
--- a/examples/org.eclipse.graphiti.doc/about.html
+++ b/examples/org.eclipse.graphiti.doc/about.html
@@ -2,28 +2,27 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
 <title>About</title>
 </head>
 <body lang="EN-US">
-        <h3>About This Content</h3>
+<h2>About This Content</h2>
+ 
+<p>June 5, 2006</p>
+<h3>License</h3>
 
-        <p>April 14, 2010</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 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>The Eclipse Foundation makes available all content in this plug-in ("Content").  
-        Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
-        Eclipse Public License Version 1.0 ("EPL").  A copy of the EPL is available 
-        at <a href="http://www.eclipse.org/org/documents/epl-v10.php" shape="rect">http://www.eclipse.org/legal/epl-v10.html</a>.
-        For purposes of the EPL, "Program" will mean the Content.</p>
-
-        <p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-        being redistributed by another party ("Redistributor") and different terms and conditions may
-        apply to your use of any object code in the Content.  Check the Redistributor's license 
-        that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-        indicated below, the terms and conditions of the EPL still apply to any source code in the Content
-        and such source code may be obtained at <a href="http://www.eclipse.org/" shape="rect">http://www.eclipse.org</a>.</p>
-        <p align="right"><small><a href="#top" shape="rect">go to top</a></small></p>
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
 
 </body>
 </html>
\ No newline at end of file
diff --git a/examples/org.eclipse.graphiti.doc/build.properties b/examples/org.eclipse.graphiti.doc/build.properties
index c0015b0..f5461ea 100644
--- a/examples/org.eclipse.graphiti.doc/build.properties
+++ b/examples/org.eclipse.graphiti.doc/build.properties
@@ -1,19 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
-
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = .,\
                META-INF/,\
                plugin.properties,\
diff --git a/examples/org.eclipse.graphiti.doc/plugin.properties b/examples/org.eclipse.graphiti.doc/plugin.properties
index d60bbf0..2b79ab9 100644
--- a/examples/org.eclipse.graphiti.doc/plugin.properties
+++ b/examples/org.eclipse.graphiti.doc/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Documentation (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/examples/org.eclipse.graphiti.doc/plugin.xml b/examples/org.eclipse.graphiti.doc/plugin.xml
index fbe4364..d438094 100644
--- a/examples/org.eclipse.graphiti.doc/plugin.xml
+++ b/examples/org.eclipse.graphiti.doc/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.2"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2010 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/examples/org.eclipse.graphiti.doc/pom.xml b/examples/org.eclipse.graphiti.doc/pom.xml
index 7100ac5..fd6d064 100644
--- a/examples/org.eclipse.graphiti.doc/pom.xml
+++ b/examples/org.eclipse.graphiti.doc/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.doc/resources/schema.css b/examples/org.eclipse.graphiti.doc/resources/schema.css
index fb2028d..5e73927 100644
--- a/examples/org.eclipse.graphiti.doc/resources/schema.css
+++ b/examples/org.eclipse.graphiti.doc/resources/schema.css
@@ -1,13 +1,15 @@
-/*******************************************************************************
- * Copyright (c) 2003 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 
 H6.SchemaHeader {
 	font-size:16px; 
diff --git a/examples/org.eclipse.graphiti.doc/toc.xml b/examples/org.eclipse.graphiti.doc/toc.xml
index b85beac..879e9d2 100644
--- a/examples/org.eclipse.graphiti.doc/toc.xml
+++ b/examples/org.eclipse.graphiti.doc/toc.xml
@@ -1,20 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
 <?NLS TYPE="org.eclipse.help.toc"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2011 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-       Bug 361638 - Add Chess example
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <toc label="Graphiti Developer Guide">
diff --git a/examples/org.eclipse.graphiti.doc/toc_concepts.xml b/examples/org.eclipse.graphiti.doc/toc_concepts.xml
index a16cfbd..c5fa678 100644
--- a/examples/org.eclipse.graphiti.doc/toc_concepts.xml
+++ b/examples/org.eclipse.graphiti.doc/toc_concepts.xml
@@ -1,18 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2011 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
  
  
diff --git a/examples/org.eclipse.graphiti.doc/toc_graphiti.xml b/examples/org.eclipse.graphiti.doc/toc_graphiti.xml
index 18e19ab..9bc4587 100644
--- a/examples/org.eclipse.graphiti.doc/toc_graphiti.xml
+++ b/examples/org.eclipse.graphiti.doc/toc_graphiti.xml
@@ -2,19 +2,18 @@
 <?NLS TYPE="org.eclipse.help.toc"?>
 
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2011 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <toc label="Graphics framework"> 
diff --git a/examples/org.eclipse.graphiti.examples.chess/about.html b/examples/org.eclipse.graphiti.examples.chess/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.examples.chess/about.html
+++ b/examples/org.eclipse.graphiti.examples.chess/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.examples.chess/build.properties b/examples/org.eclipse.graphiti.examples.chess/build.properties
index 2dcab21..f9e5ad7 100644
--- a/examples/org.eclipse.graphiti.examples.chess/build.properties
+++ b/examples/org.eclipse.graphiti.examples.chess/build.properties
@@ -1,3 +1,15 @@
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
+# Contributors:
+#    SAP SE - initial API, implementation and documentation
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/,\
            src-gen/
 bin.includes = META-INF/,\
diff --git a/examples/org.eclipse.graphiti.examples.chess/model/chess.genmodel b/examples/org.eclipse.graphiti.examples.chess/model/chess.genmodel
index a002284..19a67db 100644
--- a/examples/org.eclipse.graphiti.examples.chess/model/chess.genmodel
+++ b/examples/org.eclipse.graphiti.examples.chess/model/chess.genmodel
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0"
     xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="&lt;copyright>&#xD;&#xA;&#xD;&#xA;Copyright (c) 2011, 2011 SAP AG.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-v10.html&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;   SAP AG - initial API, implementation and documentation&#xD;&#xA;&#xD;&#xA;&lt;/copyright>"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="&lt;copyright>&#xD;&#xA;&#xD;&#xA;Copyright (c) 2011, 2011 SAP AG.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v2.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-2.0&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;   SAP AG - initial API, implementation and documentation&#xD;&#xA;&#xD;&#xA;&lt;/copyright>"
     modelDirectory="/org.eclipse.graphiti.examples.chess/src-gen" modelPluginID="org.eclipse.graphiti.examples.chess"
     templateDirectory="" modelName="Chess" importerID="org.eclipse.emf.importer.ecore"
     complianceLevel="6.0" copyrightFields="false">
diff --git a/examples/org.eclipse.graphiti.examples.chess/plugin.properties b/examples/org.eclipse.graphiti.examples.chess/plugin.properties
index 96c7489..f57e71c 100644
--- a/examples/org.eclipse.graphiti.examples.chess/plugin.properties
+++ b/examples/org.eclipse.graphiti.examples.chess/plugin.properties
@@ -1,15 +1,15 @@
-# <copyright>
-# 
-# Copyright (c) 2011, 2011 SAP AG.
-# 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
-# 
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
-# 
-# </copyright>
+#    SAP SE - initial API, implementation and documentation
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 #Properties file for org.eclipse.graphiti.examples.chess
 Bundle-Vendor = Eclipse Modeling Project
diff --git a/examples/org.eclipse.graphiti.examples.chess/plugin.xml b/examples/org.eclipse.graphiti.examples.chess/plugin.xml
index 8b70798..c7b726c 100644
--- a/examples/org.eclipse.graphiti.examples.chess/plugin.xml
+++ b/examples/org.eclipse.graphiti.examples.chess/plugin.xml
@@ -1,5 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
+<!--
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
+ -->
+
 <plugin>
    <extension
          point="org.eclipse.graphiti.ui.diagramTypes">
diff --git a/examples/org.eclipse.graphiti.examples.chess/pom.xml b/examples/org.eclipse.graphiti.examples.chess/pom.xml
index 651c837..3242518 100644
--- a/examples/org.eclipse.graphiti.examples.chess/pom.xml
+++ b/examples/org.eclipse.graphiti.examples.chess/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Board.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Board.java
index 28fa803..5fce1f4 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Board.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Board.java
@@ -1,33 +1,31 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Board</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the model object
+ * '<em><b>Board</b></em>'. <!-- end-user-doc -->
  *
  * <p>
  * The following features are supported:
  * <ul>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Board#getSquares <em>Squares</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Board#getPieces <em>Pieces</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Board#getSquares
+ * <em>Squares</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Board#getPieces
+ * <em>Pieces</em>}</li>
  * </ul>
  * </p>
  *
@@ -37,15 +35,18 @@
  */
 public interface Board extends EObject {
 	/**
-	 * Returns the value of the '<em><b>Squares</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.graphiti.examples.mm.chess.Square}.
-	 * It is bidirectional and its opposite is '{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard <em>Board</em>}'.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Squares</b></em>' containment reference
+	 * list. The list contents are of type
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Square}. It is
+	 * bidirectional and its opposite is
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard
+	 * <em>Board</em>}'. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of the '<em>Squares</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Squares</em>' containment reference list isn't
+	 * clear, there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Squares</em>' containment reference list.
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getBoard_Squares()
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getBoard
@@ -55,15 +56,18 @@
 	EList<Square> getSquares();
 
 	/**
-	 * Returns the value of the '<em><b>Pieces</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.graphiti.examples.mm.chess.Piece}.
-	 * It is bidirectional and its opposite is '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard <em>Board</em>}'.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Pieces</b></em>' containment reference
+	 * list. The list contents are of type
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Piece}. It is bidirectional
+	 * and its opposite is
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard
+	 * <em>Board</em>}'. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of the '<em>Pieces</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Pieces</em>' containment reference list isn't
+	 * clear, there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Pieces</em>' containment reference list.
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getBoard_Pieces()
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece#getBoard
@@ -73,8 +77,8 @@
 	EList<Piece> getPieces();
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @model required="true" rankRequired="true" fileRequired="true"
 	 * @generated
 	 */
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessFactory.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessFactory.java
index 52aa710..17a542d 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessFactory.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessFactory.java
@@ -1,72 +1,69 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import org.eclipse.emf.ecore.EFactory;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Factory</b> for the model. It provides a
+ * create method for each non-abstract class of the model. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage
  * @generated
  */
 public interface ChessFactory extends EFactory {
 	/**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The singleton instance of the factory. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	ChessFactory eINSTANCE = org.eclipse.graphiti.examples.mm.chess.impl.ChessFactoryImpl.init();
 
 	/**
-	 * Returns a new object of class '<em>Board</em>'.
-	 * <!-- begin-user-doc -->
+	 * Returns a new object of class '<em>Board</em>'. <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return a new object of class '<em>Board</em>'.
 	 * @generated
 	 */
 	Board createBoard();
 
 	/**
-	 * Returns a new object of class '<em>Square</em>'.
-	 * <!-- begin-user-doc -->
+	 * Returns a new object of class '<em>Square</em>'. <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return a new object of class '<em>Square</em>'.
 	 * @generated
 	 */
 	Square createSquare();
 
 	/**
-	 * Returns a new object of class '<em>Piece</em>'.
-	 * <!-- begin-user-doc -->
+	 * Returns a new object of class '<em>Piece</em>'. <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return a new object of class '<em>Piece</em>'.
 	 * @generated
 	 */
 	Piece createPiece();
 
 	/**
-	 * Returns the package supported by this factory.
-	 * <!-- begin-user-doc -->
+	 * Returns the package supported by this factory. <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the package supported by this factory.
 	 * @generated
 	 */
 	ChessPackage getChessPackage();
 
-} //ChessFactory
+} // ChessFactory
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessPackage.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessPackage.java
index f995c91..34932c7 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessPackage.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/ChessPackage.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import org.eclipse.emf.ecore.EAttribute;
@@ -21,57 +19,55 @@
 import org.eclipse.emf.ecore.EReference;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
+ * <!-- begin-user-doc --> The <b>Package</b> for the model. It contains
+ * accessors for the meta objects to represent
  * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
+ * <li>each class,</li>
+ * <li>each feature of each class,</li>
+ * <li>each enum,</li>
+ * <li>and each data type</li>
  * </ul>
  * <!-- end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessFactory
  * @model kind="package"
  * @generated
  */
 public interface ChessPackage extends EPackage {
 	/**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The package name. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	String eNAME = "chess";
 
 	/**
-	 * The package namespace URI.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The package namespace URI. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	String eNS_URI = "http://eclipse.org/graphiti/examples/chess";
 
 	/**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The package namespace name. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	String eNS_PREFIX = "chess";
 
 	/**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The singleton instance of the package. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	ChessPackage eINSTANCE = org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl.init();
 
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl <em>Board</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl
+	 * <em>Board</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getBoard()
 	 * @generated
@@ -79,36 +75,37 @@
 	int BOARD = 0;
 
 	/**
-	 * The feature id for the '<em><b>Squares</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Squares</b></em>' containment reference
+	 * list. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int BOARD__SQUARES = 0;
 
 	/**
-	 * The feature id for the '<em><b>Pieces</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Pieces</b></em>' containment reference
+	 * list. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int BOARD__PIECES = 1;
 
 	/**
-	 * The number of structural features of the '<em>Board</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The number of structural features of the '<em>Board</em>' class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int BOARD_FEATURE_COUNT = 2;
 
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl <em>Square</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl
+	 * <em>Square</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getSquare()
 	 * @generated
@@ -116,73 +113,73 @@
 	int SQUARE = 1;
 
 	/**
-	 * The feature id for the '<em><b>Board</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Board</b></em>' container reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE__BOARD = 0;
 
 	/**
-	 * The feature id for the '<em><b>Index</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Index</b></em>' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE__INDEX = 1;
 
 	/**
-	 * The feature id for the '<em><b>File</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>File</b></em>' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE__FILE = 2;
 
 	/**
-	 * The feature id for the '<em><b>Rank</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Rank</b></em>' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE__RANK = 3;
 
 	/**
-	 * The feature id for the '<em><b>Color</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Color</b></em>' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE__COLOR = 4;
 
 	/**
-	 * The feature id for the '<em><b>Piece</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Piece</b></em>' reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE__PIECE = 5;
 
 	/**
-	 * The number of structural features of the '<em>Square</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The number of structural features of the '<em>Square</em>' class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int SQUARE_FEATURE_COUNT = 6;
 
-
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl <em>Piece</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl
+	 * <em>Piece</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getPiece()
 	 * @generated
@@ -190,54 +187,55 @@
 	int PIECE = 2;
 
 	/**
-	 * The feature id for the '<em><b>Owner</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Owner</b></em>' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int PIECE__OWNER = 0;
 
 	/**
-	 * The feature id for the '<em><b>Type</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Type</b></em>' attribute. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int PIECE__TYPE = 1;
 
 	/**
-	 * The feature id for the '<em><b>Square</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Square</b></em>' reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int PIECE__SQUARE = 2;
 
 	/**
-	 * The feature id for the '<em><b>Board</b></em>' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The feature id for the '<em><b>Board</b></em>' container reference. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int PIECE__BOARD = 3;
 
 	/**
-	 * The number of structural features of the '<em>Piece</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The number of structural features of the '<em>Piece</em>' class. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 * @ordered
 	 */
 	int PIECE_FEATURE_COUNT = 4;
 
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.Ranks <em>Ranks</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Ranks <em>Ranks</em>}'
+	 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.Ranks
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getRanks()
 	 * @generated
@@ -245,9 +243,10 @@
 	int RANKS = 3;
 
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.Files <em>Files</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Files <em>Files</em>}'
+	 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.Files
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getFiles()
 	 * @generated
@@ -255,31 +254,32 @@
 	int FILES = 4;
 
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.Colors <em>Colors</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Colors <em>Colors</em>}'
+	 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getColors()
 	 * @generated
 	 */
 	int COLORS = 5;
 
-
 	/**
-	 * The meta object id for the '{@link org.eclipse.graphiti.examples.mm.chess.Types <em>Types</em>}' enum.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The meta object id for the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Types <em>Types</em>}'
+	 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.graphiti.examples.mm.chess.Types
 	 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getTypes()
 	 * @generated
 	 */
 	int TYPES = 6;
 
-
 	/**
-	 * Returns the meta object for class '{@link org.eclipse.graphiti.examples.mm.chess.Board <em>Board</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for class
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Board <em>Board</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for class '<em>Board</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Board
 	 * @generated
@@ -287,10 +287,12 @@
 	EClass getBoard();
 
 	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.graphiti.examples.mm.chess.Board#getSquares <em>Squares</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Squares</em>'.
+	 * Returns the meta object for the containment reference list
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Board#getSquares
+	 * <em>Squares</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @return the meta object for the containment reference list
+	 *         '<em>Squares</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Board#getSquares()
 	 * @see #getBoard()
 	 * @generated
@@ -298,10 +300,12 @@
 	EReference getBoard_Squares();
 
 	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.graphiti.examples.mm.chess.Board#getPieces <em>Pieces</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Pieces</em>'.
+	 * Returns the meta object for the containment reference list
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Board#getPieces
+	 * <em>Pieces</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @return the meta object for the containment reference list
+	 *         '<em>Pieces</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Board#getPieces()
 	 * @see #getBoard()
 	 * @generated
@@ -309,9 +313,10 @@
 	EReference getBoard_Pieces();
 
 	/**
-	 * Returns the meta object for class '{@link org.eclipse.graphiti.examples.mm.chess.Square <em>Square</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for class
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square <em>Square</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for class '<em>Square</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square
 	 * @generated
@@ -319,9 +324,10 @@
 	EClass getSquare();
 
 	/**
-	 * Returns the meta object for the container reference '{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard <em>Board</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the container reference
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard
+	 * <em>Board</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the container reference '<em>Board</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getBoard()
 	 * @see #getSquare()
@@ -330,9 +336,10 @@
 	EReference getSquare_Board();
 
 	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.graphiti.examples.mm.chess.Square#getIndex <em>Index</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the attribute
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getIndex
+	 * <em>Index</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the attribute '<em>Index</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getIndex()
 	 * @see #getSquare()
@@ -341,9 +348,10 @@
 	EAttribute getSquare_Index();
 
 	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.graphiti.examples.mm.chess.Square#getFile <em>File</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the attribute
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getFile
+	 * <em>File</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the attribute '<em>File</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getFile()
 	 * @see #getSquare()
@@ -352,9 +360,10 @@
 	EAttribute getSquare_File();
 
 	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.graphiti.examples.mm.chess.Square#getRank <em>Rank</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the attribute
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getRank
+	 * <em>Rank</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the attribute '<em>Rank</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getRank()
 	 * @see #getSquare()
@@ -363,9 +372,10 @@
 	EAttribute getSquare_Rank();
 
 	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.graphiti.examples.mm.chess.Square#getColor <em>Color</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the attribute
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getColor
+	 * <em>Color</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the attribute '<em>Color</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getColor()
 	 * @see #getSquare()
@@ -374,9 +384,10 @@
 	EAttribute getSquare_Color();
 
 	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece <em>Piece</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the reference
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece
+	 * <em>Piece</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the reference '<em>Piece</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square#getPiece()
 	 * @see #getSquare()
@@ -385,9 +396,10 @@
 	EReference getSquare_Piece();
 
 	/**
-	 * Returns the meta object for class '{@link org.eclipse.graphiti.examples.mm.chess.Piece <em>Piece</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for class
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece <em>Piece</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for class '<em>Piece</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece
 	 * @generated
@@ -395,9 +407,10 @@
 	EClass getPiece();
 
 	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getOwner <em>Owner</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the attribute
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getOwner
+	 * <em>Owner</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the attribute '<em>Owner</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece#getOwner()
 	 * @see #getPiece()
@@ -406,9 +419,10 @@
 	EAttribute getPiece_Owner();
 
 	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getType <em>Type</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the attribute
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getType
+	 * <em>Type</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the attribute '<em>Type</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece#getType()
 	 * @see #getPiece()
@@ -417,9 +431,10 @@
 	EAttribute getPiece_Type();
 
 	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare <em>Square</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the reference
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare
+	 * <em>Square</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the reference '<em>Square</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece#getSquare()
 	 * @see #getPiece()
@@ -428,9 +443,10 @@
 	EReference getPiece_Square();
 
 	/**
-	 * Returns the meta object for the container reference '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard <em>Board</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for the container reference
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard
+	 * <em>Board</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for the container reference '<em>Board</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece#getBoard()
 	 * @see #getPiece()
@@ -439,9 +455,10 @@
 	EReference getPiece_Board();
 
 	/**
-	 * Returns the meta object for enum '{@link org.eclipse.graphiti.examples.mm.chess.Ranks <em>Ranks</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for enum
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Ranks <em>Ranks</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for enum '<em>Ranks</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Ranks
 	 * @generated
@@ -449,9 +466,10 @@
 	EEnum getRanks();
 
 	/**
-	 * Returns the meta object for enum '{@link org.eclipse.graphiti.examples.mm.chess.Files <em>Files</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for enum
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Files <em>Files</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for enum '<em>Files</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Files
 	 * @generated
@@ -459,9 +477,10 @@
 	EEnum getFiles();
 
 	/**
-	 * Returns the meta object for enum '{@link org.eclipse.graphiti.examples.mm.chess.Colors <em>Colors</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for enum
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Colors <em>Colors</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for enum '<em>Colors</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 	 * @generated
@@ -469,9 +488,10 @@
 	EEnum getColors();
 
 	/**
-	 * Returns the meta object for enum '{@link org.eclipse.graphiti.examples.mm.chess.Types <em>Types</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the meta object for enum
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Types <em>Types</em>}'.
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the meta object for enum '<em>Types</em>'.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Types
 	 * @generated
@@ -479,31 +499,33 @@
 	EEnum getTypes();
 
 	/**
-	 * Returns the factory that creates the instances of the model.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the factory that creates the instances of the model. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the factory that creates the instances of the model.
 	 * @generated
 	 */
 	ChessFactory getChessFactory();
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * Defines literals for the meta objects that represent
+	 * <!-- begin-user-doc --> Defines literals for the meta objects that
+	 * represent
 	 * <ul>
-	 *   <li>each class,</li>
-	 *   <li>each feature of each class,</li>
-	 *   <li>each enum,</li>
-	 *   <li>and each data type</li>
+	 * <li>each class,</li>
+	 * <li>each feature of each class,</li>
+	 * <li>each enum,</li>
+	 * <li>and each data type</li>
 	 * </ul>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	interface Literals {
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl <em>Board</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl
+		 * <em>Board</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getBoard()
 		 * @generated
@@ -511,25 +533,27 @@
 		EClass BOARD = eINSTANCE.getBoard();
 
 		/**
-		 * The meta object literal for the '<em><b>Squares</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Squares</b></em>' containment
+		 * reference list feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EReference BOARD__SQUARES = eINSTANCE.getBoard_Squares();
 
 		/**
-		 * The meta object literal for the '<em><b>Pieces</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Pieces</b></em>' containment
+		 * reference list feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EReference BOARD__PIECES = eINSTANCE.getBoard_Pieces();
 
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl <em>Square</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl
+		 * <em>Square</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc
+		 * -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getSquare()
 		 * @generated
@@ -537,57 +561,58 @@
 		EClass SQUARE = eINSTANCE.getSquare();
 
 		/**
-		 * The meta object literal for the '<em><b>Board</b></em>' container reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Board</b></em>' container
+		 * reference feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EReference SQUARE__BOARD = eINSTANCE.getSquare_Board();
 
 		/**
-		 * The meta object literal for the '<em><b>Index</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Index</b></em>' attribute
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EAttribute SQUARE__INDEX = eINSTANCE.getSquare_Index();
 
 		/**
-		 * The meta object literal for the '<em><b>File</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>File</b></em>' attribute
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EAttribute SQUARE__FILE = eINSTANCE.getSquare_File();
 
 		/**
-		 * The meta object literal for the '<em><b>Rank</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Rank</b></em>' attribute
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EAttribute SQUARE__RANK = eINSTANCE.getSquare_Rank();
 
 		/**
-		 * The meta object literal for the '<em><b>Color</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Color</b></em>' attribute
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EAttribute SQUARE__COLOR = eINSTANCE.getSquare_Color();
 
 		/**
-		 * The meta object literal for the '<em><b>Piece</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Piece</b></em>' reference
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EReference SQUARE__PIECE = eINSTANCE.getSquare_Piece();
 
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl <em>Piece</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl
+		 * <em>Piece</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getPiece()
 		 * @generated
@@ -595,41 +620,42 @@
 		EClass PIECE = eINSTANCE.getPiece();
 
 		/**
-		 * The meta object literal for the '<em><b>Owner</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Owner</b></em>' attribute
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EAttribute PIECE__OWNER = eINSTANCE.getPiece_Owner();
 
 		/**
-		 * The meta object literal for the '<em><b>Type</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Type</b></em>' attribute
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EAttribute PIECE__TYPE = eINSTANCE.getPiece_Type();
 
 		/**
-		 * The meta object literal for the '<em><b>Square</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Square</b></em>' reference
+		 * feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EReference PIECE__SQUARE = eINSTANCE.getPiece_Square();
 
 		/**
-		 * The meta object literal for the '<em><b>Board</b></em>' container reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the '<em><b>Board</b></em>' container
+		 * reference feature. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @generated
 		 */
 		EReference PIECE__BOARD = eINSTANCE.getPiece_Board();
 
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.Ranks <em>Ranks</em>}' enum.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.Ranks <em>Ranks</em>}'
+		 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.Ranks
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getRanks()
 		 * @generated
@@ -637,9 +663,10 @@
 		EEnum RANKS = eINSTANCE.getRanks();
 
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.Files <em>Files</em>}' enum.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.Files <em>Files</em>}'
+		 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.Files
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getFiles()
 		 * @generated
@@ -647,9 +674,10 @@
 		EEnum FILES = eINSTANCE.getFiles();
 
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.Colors <em>Colors</em>}' enum.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.Colors
+		 * <em>Colors</em>}' enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getColors()
 		 * @generated
@@ -657,9 +685,10 @@
 		EEnum COLORS = eINSTANCE.getColors();
 
 		/**
-		 * The meta object literal for the '{@link org.eclipse.graphiti.examples.mm.chess.Types <em>Types</em>}' enum.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
+		 * The meta object literal for the
+		 * '{@link org.eclipse.graphiti.examples.mm.chess.Types <em>Types</em>}'
+		 * enum. <!-- begin-user-doc --> <!-- end-user-doc -->
+		 * 
 		 * @see org.eclipse.graphiti.examples.mm.chess.Types
 		 * @see org.eclipse.graphiti.examples.mm.chess.impl.ChessPackageImpl#getTypes()
 		 * @generated
@@ -668,4 +697,4 @@
 
 	}
 
-} //ChessPackage
+} // ChessPackage
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Colors.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Colors.java
index 0c69821..9aa4a7f 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Colors.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Colors.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import java.util.Arrays;
@@ -21,27 +19,28 @@
 import org.eclipse.emf.common.util.Enumerator;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Colors</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the literals of the enumeration
+ * '<em><b>Colors</b></em>', and utility methods for working with them. <!--
+ * end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getColors()
  * @model
  * @generated
  */
 public enum Colors implements Enumerator {
 	/**
-	 * The '<em><b>None</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>None</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #NONE_VALUE
 	 * @generated
 	 * @ordered
 	 */
-	NONE(0, "none", "none"), /**
-	 * The '<em><b>Light</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	NONE(0, "none", "none"),
+	/**
+	 * The '<em><b>Light</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #LIGHT_VALUE
 	 * @generated
 	 * @ordered
@@ -49,9 +48,9 @@
 	LIGHT(1, "light", "light"),
 
 	/**
-	 * The '<em><b>Dark</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Dark</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #DARK_VALUE
 	 * @generated
 	 * @ordered
@@ -59,13 +58,13 @@
 	DARK(2, "dark", "dark");
 
 	/**
-	 * The '<em><b>None</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>None</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>None</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #NONE
 	 * @model name="none"
 	 * @generated
@@ -74,13 +73,13 @@
 	public static final int NONE_VALUE = 0;
 
 	/**
-	 * The '<em><b>Light</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Light</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Light</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #LIGHT
 	 * @model name="light"
 	 * @generated
@@ -89,13 +88,13 @@
 	public static final int LIGHT_VALUE = 1;
 
 	/**
-	 * The '<em><b>Dark</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Dark</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Dark</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #DARK
 	 * @model name="dark"
 	 * @generated
@@ -104,30 +103,25 @@
 	public static final int DARK_VALUE = 2;
 
 	/**
-	 * An array of all the '<em><b>Colors</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * An array of all the '<em><b>Colors</b></em>' enumerators. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
-	private static final Colors[] VALUES_ARRAY =
-		new Colors[] {
-			NONE,
-			LIGHT,
-			DARK,
-		};
+	private static final Colors[] VALUES_ARRAY = new Colors[] { NONE, LIGHT, DARK, };
 
 	/**
 	 * A public read-only list of all the '<em><b>Colors</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static final List<Colors> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
 
 	/**
-	 * Returns the '<em><b>Colors</b></em>' literal with the specified literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Colors</b></em>' literal with the specified literal
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Colors get(String literal) {
@@ -142,8 +136,8 @@
 
 	/**
 	 * Returns the '<em><b>Colors</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Colors getByName(String name) {
@@ -157,45 +151,48 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Colors</b></em>' literal with the specified integer value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Colors</b></em>' literal with the specified integer
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Colors get(int value) {
 		switch (value) {
-			case NONE_VALUE: return NONE;
-			case LIGHT_VALUE: return LIGHT;
-			case DARK_VALUE: return DARK;
+		case NONE_VALUE:
+			return NONE;
+		case LIGHT_VALUE:
+			return LIGHT;
+		case DARK_VALUE:
+			return DARK;
 		}
 		return null;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final int value;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String name;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String literal;
 
 	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Only this class can construct instances. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private Colors(int value, String name, String literal) {
@@ -205,41 +202,41 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public int getValue() {
-	  return value;
+		return value;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getName() {
-	  return name;
+		return name;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getLiteral() {
-	  return literal;
+		return literal;
 	}
 
 	/**
-	 * Returns the literal value of the enumerator, which is its string representation.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the literal value of the enumerator, which is its string
+	 * representation. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String toString() {
 		return literal;
 	}
-	
-} //Colors
+
+} // Colors
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Files.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Files.java
index bd9f996..4ced7d2 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Files.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Files.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import java.util.Arrays;
@@ -21,27 +19,28 @@
 import org.eclipse.emf.common.util.Enumerator;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Files</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the literals of the enumeration
+ * '<em><b>Files</b></em>', and utility methods for working with them. <!--
+ * end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getFiles()
  * @model
  * @generated
  */
 public enum Files implements Enumerator {
 	/**
-	 * The '<em><b>None</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>None</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #NONE_VALUE
 	 * @generated
 	 * @ordered
 	 */
-	NONE(0, "none", "none"), /**
-	 * The '<em><b>A</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	NONE(0, "none", "none"),
+	/**
+	 * The '<em><b>A</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #A_VALUE
 	 * @generated
 	 * @ordered
@@ -49,9 +48,9 @@
 	A(1, "A", "A"),
 
 	/**
-	 * The '<em><b>B</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>B</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #B_VALUE
 	 * @generated
 	 * @ordered
@@ -59,9 +58,9 @@
 	B(2, "B", "B"),
 
 	/**
-	 * The '<em><b>C</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>C</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #C_VALUE
 	 * @generated
 	 * @ordered
@@ -69,9 +68,9 @@
 	C(3, "C", "C"),
 
 	/**
-	 * The '<em><b>D</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>D</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #D_VALUE
 	 * @generated
 	 * @ordered
@@ -79,9 +78,9 @@
 	D(4, "D", "D"),
 
 	/**
-	 * The '<em><b>E</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>E</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #E_VALUE
 	 * @generated
 	 * @ordered
@@ -89,9 +88,9 @@
 	E(5, "E", "E"),
 
 	/**
-	 * The '<em><b>F</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>F</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #F_VALUE
 	 * @generated
 	 * @ordered
@@ -99,9 +98,9 @@
 	F(6, "F", "F"),
 
 	/**
-	 * The '<em><b>G</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>G</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #G_VALUE
 	 * @generated
 	 * @ordered
@@ -109,9 +108,9 @@
 	G(7, "G", "G"),
 
 	/**
-	 * The '<em><b>H</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>H</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #H_VALUE
 	 * @generated
 	 * @ordered
@@ -119,13 +118,13 @@
 	H(8, "H", "H");
 
 	/**
-	 * The '<em><b>None</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>None</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>None</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #NONE
 	 * @model name="none"
 	 * @generated
@@ -134,13 +133,13 @@
 	public static final int NONE_VALUE = 0;
 
 	/**
-	 * The '<em><b>A</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>A</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>A</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>A</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #A
 	 * @model
 	 * @generated
@@ -149,13 +148,13 @@
 	public static final int A_VALUE = 1;
 
 	/**
-	 * The '<em><b>B</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>B</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>B</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>B</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #B
 	 * @model
 	 * @generated
@@ -164,13 +163,13 @@
 	public static final int B_VALUE = 2;
 
 	/**
-	 * The '<em><b>C</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>C</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>C</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>C</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #C
 	 * @model
 	 * @generated
@@ -179,13 +178,13 @@
 	public static final int C_VALUE = 3;
 
 	/**
-	 * The '<em><b>D</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>D</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>D</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>D</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #D
 	 * @model
 	 * @generated
@@ -194,13 +193,13 @@
 	public static final int D_VALUE = 4;
 
 	/**
-	 * The '<em><b>E</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>E</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>E</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>E</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #E
 	 * @model
 	 * @generated
@@ -209,13 +208,13 @@
 	public static final int E_VALUE = 5;
 
 	/**
-	 * The '<em><b>F</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>F</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>F</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>F</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #F
 	 * @model
 	 * @generated
@@ -224,13 +223,13 @@
 	public static final int F_VALUE = 6;
 
 	/**
-	 * The '<em><b>G</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>G</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>G</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>G</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #G
 	 * @model
 	 * @generated
@@ -239,13 +238,13 @@
 	public static final int G_VALUE = 7;
 
 	/**
-	 * The '<em><b>H</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>H</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>H</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>H</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #H
 	 * @model
 	 * @generated
@@ -254,36 +253,25 @@
 	public static final int H_VALUE = 8;
 
 	/**
-	 * An array of all the '<em><b>Files</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * An array of all the '<em><b>Files</b></em>' enumerators. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
-	private static final Files[] VALUES_ARRAY =
-		new Files[] {
-			NONE,
-			A,
-			B,
-			C,
-			D,
-			E,
-			F,
-			G,
-			H,
-		};
+	private static final Files[] VALUES_ARRAY = new Files[] { NONE, A, B, C, D, E, F, G, H, };
 
 	/**
 	 * A public read-only list of all the '<em><b>Files</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static final List<Files> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
 
 	/**
-	 * Returns the '<em><b>Files</b></em>' literal with the specified literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Files</b></em>' literal with the specified literal
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Files get(String literal) {
@@ -297,9 +285,9 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Files</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Files</b></em>' literal with the specified name. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Files getByName(String name) {
@@ -313,51 +301,60 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Files</b></em>' literal with the specified integer value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Files</b></em>' literal with the specified integer
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Files get(int value) {
 		switch (value) {
-			case NONE_VALUE: return NONE;
-			case A_VALUE: return A;
-			case B_VALUE: return B;
-			case C_VALUE: return C;
-			case D_VALUE: return D;
-			case E_VALUE: return E;
-			case F_VALUE: return F;
-			case G_VALUE: return G;
-			case H_VALUE: return H;
+		case NONE_VALUE:
+			return NONE;
+		case A_VALUE:
+			return A;
+		case B_VALUE:
+			return B;
+		case C_VALUE:
+			return C;
+		case D_VALUE:
+			return D;
+		case E_VALUE:
+			return E;
+		case F_VALUE:
+			return F;
+		case G_VALUE:
+			return G;
+		case H_VALUE:
+			return H;
 		}
 		return null;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final int value;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String name;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String literal;
 
 	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Only this class can construct instances. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private Files(int value, String name, String literal) {
@@ -367,41 +364,41 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public int getValue() {
-	  return value;
+		return value;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getName() {
-	  return name;
+		return name;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getLiteral() {
-	  return literal;
+		return literal;
 	}
 
 	/**
-	 * Returns the literal value of the enumerator, which is its string representation.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the literal value of the enumerator, which is its string
+	 * representation. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String toString() {
 		return literal;
 	}
-	
-} //Files
+
+} // Files
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Piece.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Piece.java
index 780bb4b..9978924 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Piece.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Piece.java
@@ -1,33 +1,34 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import org.eclipse.emf.ecore.EObject;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Piece</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the model object
+ * '<em><b>Piece</b></em>'. <!-- end-user-doc -->
  *
  * <p>
  * The following features are supported:
  * <ul>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getOwner <em>Owner</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare <em>Square</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard <em>Board</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getOwner
+ * <em>Owner</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getType
+ * <em>Type</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare
+ * <em>Square</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard
+ * <em>Board</em>}</li>
  * </ul>
  * </p>
  *
@@ -37,14 +38,16 @@
  */
 public interface Piece extends EObject {
 	/**
-	 * Returns the value of the '<em><b>Owner</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.graphiti.examples.mm.chess.Colors}.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Owner</b></em>' attribute. The literals
+	 * are from the enumeration
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Colors}. <!--
+	 * begin-user-doc -->
 	 * <p>
-	 * If the meaning of the '<em>Owner</em>' attribute isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Owner</em>' attribute isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Owner</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 	 * @see #setOwner(Colors)
@@ -55,10 +58,12 @@
 	Colors getOwner();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getOwner <em>Owner</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Owner</em>' attribute.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getOwner
+	 * <em>Owner</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Owner</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 	 * @see #getOwner()
 	 * @generated
@@ -66,14 +71,16 @@
 	void setOwner(Colors value);
 
 	/**
-	 * Returns the value of the '<em><b>Type</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.graphiti.examples.mm.chess.Types}.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Type</b></em>' attribute. The literals
+	 * are from the enumeration
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Types}. <!-- begin-user-doc
+	 * -->
 	 * <p>
-	 * If the meaning of the '<em>Type</em>' attribute isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Type</em>' attribute isn't clear, there really
+	 * should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Type</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Types
 	 * @see #setType(Types)
@@ -84,10 +91,12 @@
 	Types getType();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getType <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Type</em>' attribute.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getType
+	 * <em>Type</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Type</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Types
 	 * @see #getType()
 	 * @generated
@@ -95,14 +104,16 @@
 	void setType(Types value);
 
 	/**
-	 * Returns the value of the '<em><b>Square</b></em>' reference.
-	 * It is bidirectional and its opposite is '{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece <em>Piece</em>}'.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Square</b></em>' reference. It is
+	 * bidirectional and its opposite is
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece
+	 * <em>Piece</em>}'. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of the '<em>Square</em>' reference isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Square</em>' reference isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Square</em>' reference.
 	 * @see #setSquare(Square)
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getPiece_Square()
@@ -113,24 +124,29 @@
 	Square getSquare();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare <em>Square</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Square</em>' reference.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare
+	 * <em>Square</em>}' reference. <!-- begin-user-doc --> <!-- end-user-doc
+	 * -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Square</em>' reference.
 	 * @see #getSquare()
 	 * @generated
 	 */
 	void setSquare(Square value);
 
 	/**
-	 * Returns the value of the '<em><b>Board</b></em>' container reference.
-	 * It is bidirectional and its opposite is '{@link org.eclipse.graphiti.examples.mm.chess.Board#getPieces <em>Pieces</em>}'.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Board</b></em>' container reference. It
+	 * is bidirectional and its opposite is
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Board#getPieces
+	 * <em>Pieces</em>}'. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of the '<em>Board</em>' container reference isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Board</em>' container reference.
 	 * @see #setBoard(Board)
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getPiece_Board()
@@ -141,10 +157,13 @@
 	Board getBoard();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard <em>Board</em>}' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Board</em>' container reference.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getBoard
+	 * <em>Board</em>}' container reference. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Board</em>' container reference.
 	 * @see #getBoard()
 	 * @generated
 	 */
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Ranks.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Ranks.java
index 4fc4d73..d31f6b7 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Ranks.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Ranks.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import java.util.Arrays;
@@ -21,27 +19,28 @@
 import org.eclipse.emf.common.util.Enumerator;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Ranks</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the literals of the enumeration
+ * '<em><b>Ranks</b></em>', and utility methods for working with them. <!--
+ * end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getRanks()
  * @model
  * @generated
  */
 public enum Ranks implements Enumerator {
 	/**
-	 * The '<em><b>None</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>None</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #NONE_VALUE
 	 * @generated
 	 * @ordered
 	 */
-	NONE(0, "none", "none"), /**
-	 * The '<em><b>One</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	NONE(0, "none", "none"),
+	/**
+	 * The '<em><b>One</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #ONE_VALUE
 	 * @generated
 	 * @ordered
@@ -49,9 +48,9 @@
 	ONE(1, "one", "one"),
 
 	/**
-	 * The '<em><b>Two</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Two</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #TWO_VALUE
 	 * @generated
 	 * @ordered
@@ -59,9 +58,9 @@
 	TWO(2, "two", "two"),
 
 	/**
-	 * The '<em><b>Three</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Three</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #THREE_VALUE
 	 * @generated
 	 * @ordered
@@ -69,9 +68,9 @@
 	THREE(3, "three", "three"),
 
 	/**
-	 * The '<em><b>Four</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Four</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #FOUR_VALUE
 	 * @generated
 	 * @ordered
@@ -79,9 +78,9 @@
 	FOUR(4, "four", "four"),
 
 	/**
-	 * The '<em><b>Five</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Five</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #FIVE_VALUE
 	 * @generated
 	 * @ordered
@@ -89,9 +88,9 @@
 	FIVE(5, "five", "five"),
 
 	/**
-	 * The '<em><b>Six</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Six</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #SIX_VALUE
 	 * @generated
 	 * @ordered
@@ -99,9 +98,9 @@
 	SIX(6, "six", "six"),
 
 	/**
-	 * The '<em><b>Seven</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Seven</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #SEVEN_VALUE
 	 * @generated
 	 * @ordered
@@ -109,9 +108,9 @@
 	SEVEN(7, "seven", "seven"),
 
 	/**
-	 * The '<em><b>Eight</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Eight</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #EIGHT_VALUE
 	 * @generated
 	 * @ordered
@@ -119,13 +118,13 @@
 	EIGHT(8, "eight", "eight");
 
 	/**
-	 * The '<em><b>None</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>None</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>None</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #NONE
 	 * @model name="none"
 	 * @generated
@@ -134,13 +133,13 @@
 	public static final int NONE_VALUE = 0;
 
 	/**
-	 * The '<em><b>One</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>One</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>One</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>One</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #ONE
 	 * @model name="one"
 	 * @generated
@@ -149,13 +148,13 @@
 	public static final int ONE_VALUE = 1;
 
 	/**
-	 * The '<em><b>Two</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Two</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>Two</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>Two</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #TWO
 	 * @model name="two"
 	 * @generated
@@ -164,13 +163,13 @@
 	public static final int TWO_VALUE = 2;
 
 	/**
-	 * The '<em><b>Three</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Three</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Three</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #THREE
 	 * @model name="three"
 	 * @generated
@@ -179,13 +178,13 @@
 	public static final int THREE_VALUE = 3;
 
 	/**
-	 * The '<em><b>Four</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Four</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Four</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #FOUR
 	 * @model name="four"
 	 * @generated
@@ -194,13 +193,13 @@
 	public static final int FOUR_VALUE = 4;
 
 	/**
-	 * The '<em><b>Five</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Five</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Five</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #FIVE
 	 * @model name="five"
 	 * @generated
@@ -209,13 +208,13 @@
 	public static final int FIVE_VALUE = 5;
 
 	/**
-	 * The '<em><b>Six</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Six</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of '<em><b>Six</b></em>' literal object isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of '<em><b>Six</b></em>' literal object isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #SIX
 	 * @model name="six"
 	 * @generated
@@ -224,13 +223,13 @@
 	public static final int SIX_VALUE = 6;
 
 	/**
-	 * The '<em><b>Seven</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Seven</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Seven</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #SEVEN
 	 * @model name="seven"
 	 * @generated
@@ -239,13 +238,13 @@
 	public static final int SEVEN_VALUE = 7;
 
 	/**
-	 * The '<em><b>Eight</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Eight</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Eight</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #EIGHT
 	 * @model name="eight"
 	 * @generated
@@ -254,36 +253,25 @@
 	public static final int EIGHT_VALUE = 8;
 
 	/**
-	 * An array of all the '<em><b>Ranks</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * An array of all the '<em><b>Ranks</b></em>' enumerators. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
-	private static final Ranks[] VALUES_ARRAY =
-		new Ranks[] {
-			NONE,
-			ONE,
-			TWO,
-			THREE,
-			FOUR,
-			FIVE,
-			SIX,
-			SEVEN,
-			EIGHT,
-		};
+	private static final Ranks[] VALUES_ARRAY = new Ranks[] { NONE, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, };
 
 	/**
 	 * A public read-only list of all the '<em><b>Ranks</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static final List<Ranks> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
 
 	/**
-	 * Returns the '<em><b>Ranks</b></em>' literal with the specified literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Ranks</b></em>' literal with the specified literal
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Ranks get(String literal) {
@@ -297,9 +285,9 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Ranks</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Ranks</b></em>' literal with the specified name. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Ranks getByName(String name) {
@@ -313,51 +301,60 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Ranks</b></em>' literal with the specified integer value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Ranks</b></em>' literal with the specified integer
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Ranks get(int value) {
 		switch (value) {
-			case NONE_VALUE: return NONE;
-			case ONE_VALUE: return ONE;
-			case TWO_VALUE: return TWO;
-			case THREE_VALUE: return THREE;
-			case FOUR_VALUE: return FOUR;
-			case FIVE_VALUE: return FIVE;
-			case SIX_VALUE: return SIX;
-			case SEVEN_VALUE: return SEVEN;
-			case EIGHT_VALUE: return EIGHT;
+		case NONE_VALUE:
+			return NONE;
+		case ONE_VALUE:
+			return ONE;
+		case TWO_VALUE:
+			return TWO;
+		case THREE_VALUE:
+			return THREE;
+		case FOUR_VALUE:
+			return FOUR;
+		case FIVE_VALUE:
+			return FIVE;
+		case SIX_VALUE:
+			return SIX;
+		case SEVEN_VALUE:
+			return SEVEN;
+		case EIGHT_VALUE:
+			return EIGHT;
 		}
 		return null;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final int value;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String name;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String literal;
 
 	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Only this class can construct instances. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private Ranks(int value, String name, String literal) {
@@ -367,41 +364,41 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public int getValue() {
-	  return value;
+		return value;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getName() {
-	  return name;
+		return name;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getLiteral() {
-	  return literal;
+		return literal;
 	}
 
 	/**
-	 * Returns the literal value of the enumerator, which is its string representation.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the literal value of the enumerator, which is its string
+	 * representation. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String toString() {
 		return literal;
 	}
-	
-} //Ranks
+
+} // Ranks
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Square.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Square.java
index 3f4a46e..3bceb9f 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Square.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Square.java
@@ -1,35 +1,38 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import org.eclipse.emf.ecore.EObject;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Square</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the model object
+ * '<em><b>Square</b></em>'. <!-- end-user-doc -->
  *
  * <p>
  * The following features are supported:
  * <ul>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard <em>Board</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getIndex <em>Index</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getFile <em>File</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getRank <em>Rank</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getColor <em>Color</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece <em>Piece</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard
+ * <em>Board</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getIndex
+ * <em>Index</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getFile
+ * <em>File</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getRank
+ * <em>Rank</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getColor
+ * <em>Color</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece
+ * <em>Piece</em>}</li>
  * </ul>
  * </p>
  *
@@ -40,14 +43,16 @@
 public interface Square extends EObject {
 
 	/**
-	 * Returns the value of the '<em><b>Board</b></em>' container reference.
-	 * It is bidirectional and its opposite is '{@link org.eclipse.graphiti.examples.mm.chess.Board#getSquares <em>Squares</em>}'.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Board</b></em>' container reference. It
+	 * is bidirectional and its opposite is
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Board#getSquares
+	 * <em>Squares</em>}'. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of the '<em>Board</em>' container reference isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Board</em>' container reference.
 	 * @see #setBoard(Board)
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getSquare_Board()
@@ -58,24 +63,27 @@
 	Board getBoard();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard <em>Board</em>}' container reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Board</em>' container reference.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getBoard
+	 * <em>Board</em>}' container reference. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Board</em>' container reference.
 	 * @see #getBoard()
 	 * @generated
 	 */
 	void setBoard(Board value);
 
 	/**
-	 * Returns the value of the '<em><b>Index</b></em>' attribute.
-	 * The default value is <code>"-1"</code>.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Index</b></em>' attribute. The default
+	 * value is <code>"-1"</code>. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of the '<em>Index</em>' attribute isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Index</em>' attribute isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Index</em>' attribute.
 	 * @see #setIndex(int)
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getSquare_Index()
@@ -85,24 +93,28 @@
 	int getIndex();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Square#getIndex <em>Index</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Index</em>' attribute.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getIndex
+	 * <em>Index</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Index</em>' attribute.
 	 * @see #getIndex()
 	 * @generated
 	 */
 	void setIndex(int value);
 
 	/**
-	 * Returns the value of the '<em><b>Piece</b></em>' reference.
-	 * It is bidirectional and its opposite is '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare <em>Square</em>}'.
-	 * <!-- begin-user-doc -->
+	 * Returns the value of the '<em><b>Piece</b></em>' reference. It is
+	 * bidirectional and its opposite is
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece#getSquare
+	 * <em>Square</em>}'. <!-- begin-user-doc -->
 	 * <p>
-	 * If the meaning of the '<em>Piece</em>' reference isn't clear,
-	 * there really should be more of a description here...
+	 * If the meaning of the '<em>Piece</em>' reference isn't clear, there
+	 * really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Piece</em>' reference.
 	 * @see #setPiece(Piece)
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getSquare_Piece()
@@ -113,21 +125,23 @@
 	Piece getPiece();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece <em>Piece</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Piece</em>' reference.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getPiece
+	 * <em>Piece</em>}' reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Piece</em>' reference.
 	 * @see #getPiece()
 	 * @generated
 	 */
 	void setPiece(Piece value);
 
 	/**
-	 * Returns the value of the '<em><b>Rank</b></em>' attribute.
-	 * The default value is <code>""</code>.
-	 * The literals are from the enumeration {@link org.eclipse.graphiti.examples.mm.chess.Ranks}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the value of the '<em><b>Rank</b></em>' attribute. The default
+	 * value is <code>""</code>. The literals are from the enumeration
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Ranks}. <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Rank</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Ranks
 	 * @see #setRank(Ranks)
@@ -138,10 +152,12 @@
 	Ranks getRank();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Square#getRank <em>Rank</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Rank</em>' attribute.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getRank
+	 * <em>Rank</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Rank</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Ranks
 	 * @see #getRank()
 	 * @generated
@@ -149,10 +165,11 @@
 	void setRank(Ranks value);
 
 	/**
-	 * Returns the value of the '<em><b>File</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.graphiti.examples.mm.chess.Files}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the value of the '<em><b>File</b></em>' attribute. The literals
+	 * are from the enumeration
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Files}. <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>File</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Files
 	 * @see #setFile(Files)
@@ -163,10 +180,12 @@
 	Files getFile();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Square#getFile <em>File</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>File</em>' attribute.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getFile
+	 * <em>File</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>File</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Files
 	 * @see #getFile()
 	 * @generated
@@ -174,10 +193,11 @@
 	void setFile(Files value);
 
 	/**
-	 * Returns the value of the '<em><b>Color</b></em>' attribute.
-	 * The literals are from the enumeration {@link org.eclipse.graphiti.examples.mm.chess.Colors}.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the value of the '<em><b>Color</b></em>' attribute. The literals
+	 * are from the enumeration
+	 * {@link org.eclipse.graphiti.examples.mm.chess.Colors}. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @return the value of the '<em>Color</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 	 * @see #setColor(Colors)
@@ -188,10 +208,12 @@
 	Colors getColor();
 
 	/**
-	 * Sets the value of the '{@link org.eclipse.graphiti.examples.mm.chess.Square#getColor <em>Color</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Color</em>' attribute.
+	 * Sets the value of the
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square#getColor
+	 * <em>Color</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Color</em>' attribute.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Colors
 	 * @see #getColor()
 	 * @generated
@@ -199,16 +221,16 @@
 	void setColor(Colors value);
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @model kind="operation" required="true"
 	 * @generated
 	 */
 	int getOffsetX();
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @model kind="operation" required="true"
 	 * @generated
 	 */
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Types.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Types.java
index 49554c1..3452844 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Types.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/Types.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess;
 
 import java.util.Arrays;
@@ -21,27 +19,28 @@
 import org.eclipse.emf.common.util.Enumerator;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the literals of the enumeration '<em><b>Types</b></em>',
- * and utility methods for working with them.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> A representation of the literals of the enumeration
+ * '<em><b>Types</b></em>', and utility methods for working with them. <!--
+ * end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#getTypes()
  * @model
  * @generated
  */
 public enum Types implements Enumerator {
 	/**
-	 * The '<em><b>None</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>None</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #NONE_VALUE
 	 * @generated
 	 * @ordered
 	 */
-	NONE(0, "none", "none"), /**
-	 * The '<em><b>King</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	NONE(0, "none", "none"),
+	/**
+	 * The '<em><b>King</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #KING_VALUE
 	 * @generated
 	 * @ordered
@@ -49,9 +48,9 @@
 	KING(1, "king", "king"),
 
 	/**
-	 * The '<em><b>Queen</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Queen</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #QUEEN_VALUE
 	 * @generated
 	 * @ordered
@@ -59,9 +58,9 @@
 	QUEEN(2, "queen", "queen"),
 
 	/**
-	 * The '<em><b>Rook</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Rook</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #ROOK_VALUE
 	 * @generated
 	 * @ordered
@@ -69,9 +68,9 @@
 	ROOK(3, "rook", "rook"),
 
 	/**
-	 * The '<em><b>Knight</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Knight</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #KNIGHT_VALUE
 	 * @generated
 	 * @ordered
@@ -79,9 +78,9 @@
 	KNIGHT(4, "knight", "knight"),
 
 	/**
-	 * The '<em><b>Bishop</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Bishop</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #BISHOP_VALUE
 	 * @generated
 	 * @ordered
@@ -89,9 +88,9 @@
 	BISHOP(5, "bishop", "bishop"),
 
 	/**
-	 * The '<em><b>Pawn</b></em>' literal object.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The '<em><b>Pawn</b></em>' literal object. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @see #PAWN_VALUE
 	 * @generated
 	 * @ordered
@@ -99,13 +98,13 @@
 	PAWN(6, "pawn", "pawn");
 
 	/**
-	 * The '<em><b>None</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>None</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>None</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #NONE
 	 * @model name="none"
 	 * @generated
@@ -114,13 +113,13 @@
 	public static final int NONE_VALUE = 0;
 
 	/**
-	 * The '<em><b>King</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>King</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>King</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #KING
 	 * @model name="king"
 	 * @generated
@@ -129,13 +128,13 @@
 	public static final int KING_VALUE = 1;
 
 	/**
-	 * The '<em><b>Queen</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Queen</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Queen</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #QUEEN
 	 * @model name="queen"
 	 * @generated
@@ -144,13 +143,13 @@
 	public static final int QUEEN_VALUE = 2;
 
 	/**
-	 * The '<em><b>Rook</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Rook</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Rook</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #ROOK
 	 * @model name="rook"
 	 * @generated
@@ -159,13 +158,13 @@
 	public static final int ROOK_VALUE = 3;
 
 	/**
-	 * The '<em><b>Knight</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Knight</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Knight</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #KNIGHT
 	 * @model name="knight"
 	 * @generated
@@ -174,13 +173,13 @@
 	public static final int KNIGHT_VALUE = 4;
 
 	/**
-	 * The '<em><b>Bishop</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Bishop</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Bishop</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #BISHOP
 	 * @model name="bishop"
 	 * @generated
@@ -189,13 +188,13 @@
 	public static final int BISHOP_VALUE = 5;
 
 	/**
-	 * The '<em><b>Pawn</b></em>' literal value.
-	 * <!-- begin-user-doc -->
+	 * The '<em><b>Pawn</b></em>' literal value. <!-- begin-user-doc -->
 	 * <p>
 	 * If the meaning of '<em><b>Pawn</b></em>' literal object isn't clear,
 	 * there really should be more of a description here...
 	 * </p>
 	 * <!-- end-user-doc -->
+	 * 
 	 * @see #PAWN
 	 * @model name="pawn"
 	 * @generated
@@ -204,34 +203,25 @@
 	public static final int PAWN_VALUE = 6;
 
 	/**
-	 * An array of all the '<em><b>Types</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * An array of all the '<em><b>Types</b></em>' enumerators. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
-	private static final Types[] VALUES_ARRAY =
-		new Types[] {
-			NONE,
-			KING,
-			QUEEN,
-			ROOK,
-			KNIGHT,
-			BISHOP,
-			PAWN,
-		};
+	private static final Types[] VALUES_ARRAY = new Types[] { NONE, KING, QUEEN, ROOK, KNIGHT, BISHOP, PAWN, };
 
 	/**
 	 * A public read-only list of all the '<em><b>Types</b></em>' enumerators.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static final List<Types> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));
 
 	/**
-	 * Returns the '<em><b>Types</b></em>' literal with the specified literal value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Types</b></em>' literal with the specified literal
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Types get(String literal) {
@@ -245,9 +235,9 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Types</b></em>' literal with the specified name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Types</b></em>' literal with the specified name. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Types getByName(String name) {
@@ -261,49 +251,56 @@
 	}
 
 	/**
-	 * Returns the '<em><b>Types</b></em>' literal with the specified integer value.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the '<em><b>Types</b></em>' literal with the specified integer
+	 * value. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static Types get(int value) {
 		switch (value) {
-			case NONE_VALUE: return NONE;
-			case KING_VALUE: return KING;
-			case QUEEN_VALUE: return QUEEN;
-			case ROOK_VALUE: return ROOK;
-			case KNIGHT_VALUE: return KNIGHT;
-			case BISHOP_VALUE: return BISHOP;
-			case PAWN_VALUE: return PAWN;
+		case NONE_VALUE:
+			return NONE;
+		case KING_VALUE:
+			return KING;
+		case QUEEN_VALUE:
+			return QUEEN;
+		case ROOK_VALUE:
+			return ROOK;
+		case KNIGHT_VALUE:
+			return KNIGHT;
+		case BISHOP_VALUE:
+			return BISHOP;
+		case PAWN_VALUE:
+			return PAWN;
 		}
 		return null;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final int value;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String name;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private final String literal;
 
 	/**
-	 * Only this class can construct instances.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Only this class can construct instances. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private Types(int value, String name, String literal) {
@@ -313,41 +310,41 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public int getValue() {
-	  return value;
+		return value;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getName() {
-	  return name;
+		return name;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String getLiteral() {
-	  return literal;
+		return literal;
 	}
 
 	/**
-	 * Returns the literal value of the enumerator, which is its string representation.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Returns the literal value of the enumerator, which is its string
+	 * representation. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String toString() {
 		return literal;
 	}
-	
-} //Types
+
+} // Types
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/BoardImpl.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/BoardImpl.java
index deb66da..a11f567 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/BoardImpl.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/BoardImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.impl;
 
 import java.util.Collection;
@@ -38,8 +36,10 @@
  * <p>
  * The following features are implemented:
  * <ul>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl#getSquares <em>Squares</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl#getPieces <em>Pieces</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl#getSquares
+ * <em>Squares</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.BoardImpl#getPieces
+ * <em>Pieces</em>}</li>
  * </ul>
  * </p>
  *
@@ -47,8 +47,9 @@
  */
 public class BoardImpl extends EObjectImpl implements Board {
 	/**
-	 * The cached value of the '{@link #getSquares() <em>Squares</em>}' containment reference list.
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * The cached value of the '{@link #getSquares() <em>Squares</em>}'
+	 * containment reference list. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getSquares()
 	 * @generated
 	 * @ordered
@@ -56,8 +57,9 @@
 	protected EList<Square> squares;
 
 	/**
-	 * The cached value of the '{@link #getPieces() <em>Pieces</em>}' containment reference list.
-	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * The cached value of the '{@link #getPieces() <em>Pieces</em>}'
+	 * containment reference list. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getPieces()
 	 * @generated
 	 * @ordered
@@ -111,6 +113,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
@@ -120,22 +123,26 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EList<Square> getSquares() {
 		if (squares == null) {
-			squares = new EObjectContainmentWithInverseEList<Square>(Square.class, this, ChessPackage.BOARD__SQUARES, ChessPackage.SQUARE__BOARD);
+			squares = new EObjectContainmentWithInverseEList<Square>(Square.class, this, ChessPackage.BOARD__SQUARES,
+					ChessPackage.SQUARE__BOARD);
 		}
 		return squares;
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EList<Piece> getPieces() {
 		if (pieces == null) {
-			pieces = new EObjectContainmentWithInverseEList<Piece>(Piece.class, this, ChessPackage.BOARD__PIECES, ChessPackage.PIECE__BOARD);
+			pieces = new EObjectContainmentWithInverseEList<Piece>(Piece.class, this, ChessPackage.BOARD__PIECES,
+					ChessPackage.PIECE__BOARD);
 		}
 		return pieces;
 	}
@@ -156,98 +163,104 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case ChessPackage.BOARD__SQUARES:
-				return ((InternalEList<InternalEObject>)(InternalEList<?>)getSquares()).basicAdd(otherEnd, msgs);
-			case ChessPackage.BOARD__PIECES:
-				return ((InternalEList<InternalEObject>)(InternalEList<?>)getPieces()).basicAdd(otherEnd, msgs);
+		case ChessPackage.BOARD__SQUARES:
+			return ((InternalEList<InternalEObject>) (InternalEList<?>) getSquares()).basicAdd(otherEnd, msgs);
+		case ChessPackage.BOARD__PIECES:
+			return ((InternalEList<InternalEObject>) (InternalEList<?>) getPieces()).basicAdd(otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case ChessPackage.BOARD__SQUARES:
-				return ((InternalEList<?>)getSquares()).basicRemove(otherEnd, msgs);
-			case ChessPackage.BOARD__PIECES:
-				return ((InternalEList<?>)getPieces()).basicRemove(otherEnd, msgs);
+		case ChessPackage.BOARD__SQUARES:
+			return ((InternalEList<?>) getSquares()).basicRemove(otherEnd, msgs);
+		case ChessPackage.BOARD__PIECES:
+			return ((InternalEList<?>) getPieces()).basicRemove(otherEnd, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case ChessPackage.BOARD__SQUARES:
-				return getSquares();
-			case ChessPackage.BOARD__PIECES:
-				return getPieces();
+		case ChessPackage.BOARD__SQUARES:
+			return getSquares();
+		case ChessPackage.BOARD__PIECES:
+			return getPieces();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@SuppressWarnings("unchecked")
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case ChessPackage.BOARD__SQUARES:
-				getSquares().clear();
-				getSquares().addAll((Collection<? extends Square>)newValue);
-				return;
-			case ChessPackage.BOARD__PIECES:
-				getPieces().clear();
-				getPieces().addAll((Collection<? extends Piece>)newValue);
-				return;
+		case ChessPackage.BOARD__SQUARES:
+			getSquares().clear();
+			getSquares().addAll((Collection<? extends Square>) newValue);
+			return;
+		case ChessPackage.BOARD__PIECES:
+			getPieces().clear();
+			getPieces().addAll((Collection<? extends Piece>) newValue);
+			return;
 		}
 		super.eSet(featureID, newValue);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case ChessPackage.BOARD__SQUARES:
-				getSquares().clear();
-				return;
-			case ChessPackage.BOARD__PIECES:
-				getPieces().clear();
-				return;
+		case ChessPackage.BOARD__SQUARES:
+			getSquares().clear();
+			return;
+		case ChessPackage.BOARD__PIECES:
+			getPieces().clear();
+			return;
 		}
 		super.eUnset(featureID);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case ChessPackage.BOARD__SQUARES:
-				return squares != null && !squares.isEmpty();
-			case ChessPackage.BOARD__PIECES:
-				return pieces != null && !pieces.isEmpty();
+		case ChessPackage.BOARD__SQUARES:
+			return squares != null && !squares.isEmpty();
+		case ChessPackage.BOARD__PIECES:
+			return pieces != null && !pieces.isEmpty();
 		}
 		return super.eIsSet(featureID);
 	}
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessFactoryImpl.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessFactoryImpl.java
index a120344..7fc2aa4 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessFactoryImpl.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessFactoryImpl.java
@@ -1,60 +1,63 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.impl;
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EDataType;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
-
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-
-import org.eclipse.graphiti.examples.mm.chess.*;
+import org.eclipse.graphiti.examples.mm.chess.Board;
+import org.eclipse.graphiti.examples.mm.chess.ChessFactory;
+import org.eclipse.graphiti.examples.mm.chess.ChessPackage;
+import org.eclipse.graphiti.examples.mm.chess.Colors;
+import org.eclipse.graphiti.examples.mm.chess.Files;
+import org.eclipse.graphiti.examples.mm.chess.Piece;
+import org.eclipse.graphiti.examples.mm.chess.Ranks;
+import org.eclipse.graphiti.examples.mm.chess.Square;
+import org.eclipse.graphiti.examples.mm.chess.Types;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model <b>Factory</b>. <!--
+ * end-user-doc -->
+ * 
  * @generated
  */
 public class ChessFactoryImpl extends EFactoryImpl implements ChessFactory {
 	/**
-	 * Creates the default factory implementation.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Creates the default factory implementation. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public static ChessFactory init() {
 		try {
-			ChessFactory theChessFactory = (ChessFactory)EPackage.Registry.INSTANCE.getEFactory("http://eclipse.org/graphiti/examples/chess"); 
+			ChessFactory theChessFactory = (ChessFactory) EPackage.Registry.INSTANCE
+					.getEFactory("http://eclipse.org/graphiti/examples/chess");
 			if (theChessFactory != null) {
 				return theChessFactory;
 			}
-		}
-		catch (Exception exception) {
+		} catch (Exception exception) {
 			EcorePlugin.INSTANCE.log(exception);
 		}
 		return new ChessFactoryImpl();
 	}
 
 	/**
-	 * Creates an instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Creates an instance of the factory. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public ChessFactoryImpl() {
@@ -62,66 +65,69 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public EObject create(EClass eClass) {
 		switch (eClass.getClassifierID()) {
-			case ChessPackage.BOARD: return createBoard();
-			case ChessPackage.SQUARE: return createSquare();
-			case ChessPackage.PIECE: return createPiece();
-			default:
-				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		case ChessPackage.BOARD:
+			return createBoard();
+		case ChessPackage.SQUARE:
+			return createSquare();
+		case ChessPackage.PIECE:
+			return createPiece();
+		default:
+			throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public Object createFromString(EDataType eDataType, String initialValue) {
 		switch (eDataType.getClassifierID()) {
-			case ChessPackage.RANKS:
-				return createRanksFromString(eDataType, initialValue);
-			case ChessPackage.FILES:
-				return createFilesFromString(eDataType, initialValue);
-			case ChessPackage.COLORS:
-				return createColorsFromString(eDataType, initialValue);
-			case ChessPackage.TYPES:
-				return createTypesFromString(eDataType, initialValue);
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
+		case ChessPackage.RANKS:
+			return createRanksFromString(eDataType, initialValue);
+		case ChessPackage.FILES:
+			return createFilesFromString(eDataType, initialValue);
+		case ChessPackage.COLORS:
+			return createColorsFromString(eDataType, initialValue);
+		case ChessPackage.TYPES:
+			return createTypesFromString(eDataType, initialValue);
+		default:
+			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
 		}
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String convertToString(EDataType eDataType, Object instanceValue) {
 		switch (eDataType.getClassifierID()) {
-			case ChessPackage.RANKS:
-				return convertRanksToString(eDataType, instanceValue);
-			case ChessPackage.FILES:
-				return convertFilesToString(eDataType, instanceValue);
-			case ChessPackage.COLORS:
-				return convertColorsToString(eDataType, instanceValue);
-			case ChessPackage.TYPES:
-				return convertTypesToString(eDataType, instanceValue);
-			default:
-				throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
+		case ChessPackage.RANKS:
+			return convertRanksToString(eDataType, instanceValue);
+		case ChessPackage.FILES:
+			return convertFilesToString(eDataType, instanceValue);
+		case ChessPackage.COLORS:
+			return convertColorsToString(eDataType, instanceValue);
+		case ChessPackage.TYPES:
+			return convertTypesToString(eDataType, instanceValue);
+		default:
+			throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
 		}
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Board createBoard() {
@@ -130,8 +136,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Square createSquare() {
@@ -140,8 +146,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Piece createPiece() {
@@ -150,19 +156,21 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Ranks createRanksFromString(EDataType eDataType, String initialValue) {
 		Ranks result = Ranks.get(initialValue);
-		if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
+		if (result == null)
+			throw new IllegalArgumentException(
+					"The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
 		return result;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String convertRanksToString(EDataType eDataType, Object instanceValue) {
@@ -170,19 +178,21 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Files createFilesFromString(EDataType eDataType, String initialValue) {
 		Files result = Files.get(initialValue);
-		if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
+		if (result == null)
+			throw new IllegalArgumentException(
+					"The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
 		return result;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String convertFilesToString(EDataType eDataType, Object instanceValue) {
@@ -190,19 +200,21 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Colors createColorsFromString(EDataType eDataType, String initialValue) {
 		Colors result = Colors.get(initialValue);
-		if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
+		if (result == null)
+			throw new IllegalArgumentException(
+					"The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
 		return result;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String convertColorsToString(EDataType eDataType, Object instanceValue) {
@@ -210,19 +222,21 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Types createTypesFromString(EDataType eDataType, String initialValue) {
 		Types result = Types.get(initialValue);
-		if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
+		if (result == null)
+			throw new IllegalArgumentException(
+					"The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
 		return result;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public String convertTypesToString(EDataType eDataType, Object instanceValue) {
@@ -230,17 +244,17 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public ChessPackage getChessPackage() {
-		return (ChessPackage)getEPackage();
+		return (ChessPackage) getEPackage();
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @deprecated
 	 * @generated
 	 */
@@ -249,4 +263,4 @@
 		return ChessPackage.eINSTANCE;
 	}
 
-} //ChessFactoryImpl
+} // ChessFactoryImpl
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessPackageImpl.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessPackageImpl.java
index 6d3affe..84f901b 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessPackageImpl.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/ChessPackageImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.impl;
 
 import org.eclipse.emf.ecore.EAttribute;
@@ -20,9 +18,7 @@
 import org.eclipse.emf.ecore.EOperation;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
-
 import org.eclipse.emf.ecore.impl.EPackageImpl;
-
 import org.eclipse.graphiti.examples.mm.chess.Board;
 import org.eclipse.graphiti.examples.mm.chess.ChessFactory;
 import org.eclipse.graphiti.examples.mm.chess.ChessPackage;
@@ -34,71 +30,71 @@
 import org.eclipse.graphiti.examples.mm.chess.Types;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model <b>Package</b>. <!--
+ * end-user-doc -->
+ * 
  * @generated
  */
 public class ChessPackageImpl extends EPackageImpl implements ChessPackage {
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EClass boardEClass = null;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EClass squareEClass = null;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EClass pieceEClass = null;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EEnum ranksEEnum = null;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EEnum filesEEnum = null;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EEnum colorsEEnum = null;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private EEnum typesEEnum = null;
 
 	/**
 	 * Creates an instance of the model <b>Package</b>, registered with
-	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-	 * package URI value.
-	 * <p>Note: the correct way to create the package is via the static
-	 * factory method {@link #init init()}, which also performs
-	 * initialization of the package, or returns the registered package,
-	 * if one already exists.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the
+	 * package package URI value.
+	 * <p>
+	 * Note: the correct way to create the package is via the static factory
+	 * method {@link #init init()}, which also performs initialization of the
+	 * package, or returns the registered package, if one already exists. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see org.eclipse.emf.ecore.EPackage.Registry
 	 * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage#eNS_URI
 	 * @see #init()
@@ -109,29 +105,35 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private static boolean isInited = false;
 
 	/**
-	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+	 * Creates, registers, and initializes the <b>Package</b> for this model,
+	 * and for any others upon which it depends.
 	 * 
-	 * <p>This method is used to initialize {@link ChessPackage#eINSTANCE} when that field is accessed.
-	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <p>
+	 * This method is used to initialize {@link ChessPackage#eINSTANCE} when
+	 * that field is accessed. Clients should not invoke it directly. Instead,
+	 * they should simply access that field to obtain the package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #eNS_URI
 	 * @see #createPackageContents()
 	 * @see #initializePackageContents()
 	 * @generated
 	 */
 	public static ChessPackage init() {
-		if (isInited) return (ChessPackage)EPackage.Registry.INSTANCE.getEPackage(ChessPackage.eNS_URI);
+		if (isInited)
+			return (ChessPackage) EPackage.Registry.INSTANCE.getEPackage(ChessPackage.eNS_URI);
 
 		// Obtain or create and register package
-		ChessPackageImpl theChessPackage = (ChessPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ChessPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new ChessPackageImpl());
+		ChessPackageImpl theChessPackage = (ChessPackageImpl) (EPackage.Registry.INSTANCE
+				.get(eNS_URI) instanceof ChessPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI)
+						: new ChessPackageImpl());
 
 		isInited = true;
 
@@ -144,15 +146,14 @@
 		// Mark meta-data to indicate it can't be changed
 		theChessPackage.freeze();
 
-  
 		// Update the registry and return the package
 		EPackage.Registry.INSTANCE.put(ChessPackage.eNS_URI, theChessPackage);
 		return theChessPackage;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EClass getBoard() {
@@ -160,26 +161,26 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EReference getBoard_Squares() {
-		return (EReference)boardEClass.getEStructuralFeatures().get(0);
+		return (EReference) boardEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EReference getBoard_Pieces() {
-		return (EReference)boardEClass.getEStructuralFeatures().get(1);
+		return (EReference) boardEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EClass getSquare() {
@@ -187,62 +188,62 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EReference getSquare_Board() {
-		return (EReference)squareEClass.getEStructuralFeatures().get(0);
+		return (EReference) squareEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EAttribute getSquare_Index() {
-		return (EAttribute)squareEClass.getEStructuralFeatures().get(1);
+		return (EAttribute) squareEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EAttribute getSquare_File() {
-		return (EAttribute)squareEClass.getEStructuralFeatures().get(2);
+		return (EAttribute) squareEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EAttribute getSquare_Rank() {
-		return (EAttribute)squareEClass.getEStructuralFeatures().get(3);
+		return (EAttribute) squareEClass.getEStructuralFeatures().get(3);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EAttribute getSquare_Color() {
-		return (EAttribute)squareEClass.getEStructuralFeatures().get(4);
+		return (EAttribute) squareEClass.getEStructuralFeatures().get(4);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EReference getSquare_Piece() {
-		return (EReference)squareEClass.getEStructuralFeatures().get(5);
+		return (EReference) squareEClass.getEStructuralFeatures().get(5);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EClass getPiece() {
@@ -250,44 +251,44 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EAttribute getPiece_Owner() {
-		return (EAttribute)pieceEClass.getEStructuralFeatures().get(0);
+		return (EAttribute) pieceEClass.getEStructuralFeatures().get(0);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EAttribute getPiece_Type() {
-		return (EAttribute)pieceEClass.getEStructuralFeatures().get(1);
+		return (EAttribute) pieceEClass.getEStructuralFeatures().get(1);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EReference getPiece_Square() {
-		return (EReference)pieceEClass.getEStructuralFeatures().get(2);
+		return (EReference) pieceEClass.getEStructuralFeatures().get(2);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EReference getPiece_Board() {
-		return (EReference)pieceEClass.getEStructuralFeatures().get(3);
+		return (EReference) pieceEClass.getEStructuralFeatures().get(3);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EEnum getRanks() {
@@ -295,8 +296,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EEnum getFiles() {
@@ -304,8 +305,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EEnum getColors() {
@@ -313,8 +314,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public EEnum getTypes() {
@@ -322,30 +323,31 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public ChessFactory getChessFactory() {
-		return (ChessFactory)getEFactoryInstance();
+		return (ChessFactory) getEFactoryInstance();
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private boolean isCreated = false;
 
 	/**
-	 * Creates the meta-model objects for the package.  This method is
-	 * guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
+	 * Creates the meta-model objects for the package. This method is guarded to
+	 * have no affect on any invocation but its first. <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void createPackageContents() {
-		if (isCreated) return;
+		if (isCreated)
+			return;
 		isCreated = true;
 
 		// Create classes and their features
@@ -375,21 +377,22 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	private boolean isInitialized = false;
 
 	/**
-	 * Complete the initialization of the package and its meta-model.  This
-	 * method is guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Complete the initialization of the package and its meta-model. This
+	 * method is guarded to have no affect on any invocation but its first. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void initializePackageContents() {
-		if (isInitialized) return;
+		if (isInitialized)
+			return;
 		isInitialized = true;
 
 		// Initialize package
@@ -405,30 +408,48 @@
 
 		// Initialize classes and features; add operations and parameters
 		initEClass(boardEClass, Board.class, "Board", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getBoard_Squares(), this.getSquare(), this.getSquare_Board(), "squares", null, 64, 64, Board.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getBoard_Pieces(), this.getPiece(), this.getPiece_Board(), "pieces", null, 0, 32, Board.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getBoard_Squares(), this.getSquare(), this.getSquare_Board(), "squares", null, 64, 64,
+				Board.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
+				!IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getBoard_Pieces(), this.getPiece(), this.getPiece_Board(), "pieces", null, 0, 32, Board.class,
+				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
+				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
 		EOperation op = addEOperation(boardEClass, this.getSquare(), "getSquare", 1, 1, IS_UNIQUE, IS_ORDERED);
 		addEParameter(op, this.getRanks(), "rank", 1, 1, IS_UNIQUE, IS_ORDERED);
 		addEParameter(op, this.getFiles(), "file", 1, 1, IS_UNIQUE, IS_ORDERED);
 
 		initEClass(squareEClass, Square.class, "Square", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getSquare_Board(), this.getBoard(), this.getBoard_Squares(), "board", null, 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSquare_Index(), ecorePackage.getEInt(), "index", "-1", 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSquare_File(), this.getFiles(), "file", null, 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSquare_Rank(), this.getRanks(), "rank", "", 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getSquare_Color(), this.getColors(), "color", null, 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getSquare_Piece(), this.getPiece(), this.getPiece_Square(), "piece", null, 0, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getSquare_Board(), this.getBoard(), this.getBoard_Squares(), "board", null, 1, 1, Square.class,
+				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
+				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getSquare_Index(), ecorePackage.getEInt(), "index", "-1", 1, 1, Square.class, !IS_TRANSIENT,
+				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getSquare_File(), this.getFiles(), "file", null, 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE,
+				IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getSquare_Rank(), this.getRanks(), "rank", "", 1, 1, Square.class, !IS_TRANSIENT, !IS_VOLATILE,
+				IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getSquare_Color(), this.getColors(), "color", null, 1, 1, Square.class, !IS_TRANSIENT,
+				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getSquare_Piece(), this.getPiece(), this.getPiece_Square(), "piece", null, 0, 1, Square.class,
+				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
+				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
 		addEOperation(squareEClass, ecorePackage.getEInt(), "getOffsetX", 1, 1, IS_UNIQUE, IS_ORDERED);
 
 		addEOperation(squareEClass, ecorePackage.getEInt(), "getOffsetY", 1, 1, IS_UNIQUE, IS_ORDERED);
 
 		initEClass(pieceEClass, Piece.class, "Piece", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getPiece_Owner(), this.getColors(), "owner", null, 0, 1, Piece.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getPiece_Type(), this.getTypes(), "type", null, 0, 1, Piece.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPiece_Square(), this.getSquare(), this.getSquare_Piece(), "square", null, 1, 1, Piece.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getPiece_Board(), this.getBoard(), this.getBoard_Pieces(), "board", null, 1, 1, Piece.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getPiece_Owner(), this.getColors(), "owner", null, 0, 1, Piece.class, !IS_TRANSIENT,
+				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getPiece_Type(), this.getTypes(), "type", null, 0, 1, Piece.class, !IS_TRANSIENT, !IS_VOLATILE,
+				IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getPiece_Square(), this.getSquare(), this.getSquare_Piece(), "square", null, 1, 1, Piece.class,
+				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
+				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getPiece_Board(), this.getBoard(), this.getBoard_Pieces(), "board", null, 1, 1, Piece.class,
+				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
+				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
 		// Initialize enums and add enum literals
 		initEEnum(ranksEEnum, Ranks.class, "Ranks");
@@ -471,4 +492,4 @@
 		createResource(eNS_URI);
 	}
 
-} //ChessPackageImpl
+} // ChessPackageImpl
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/PieceImpl.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/PieceImpl.java
index 9503648..a0d80f5 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/PieceImpl.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/PieceImpl.java
@@ -1,30 +1,24 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EcoreUtil;
-
 import org.eclipse.graphiti.examples.mm.chess.Board;
 import org.eclipse.graphiti.examples.mm.chess.ChessPackage;
 import org.eclipse.graphiti.examples.mm.chess.Colors;
@@ -33,16 +27,19 @@
 import org.eclipse.graphiti.examples.mm.chess.Types;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Piece</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model object
+ * '<em><b>Piece</b></em>'. <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
  * <ul>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getOwner <em>Owner</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getType <em>Type</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getSquare <em>Square</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getBoard <em>Board</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getOwner
+ * <em>Owner</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getType
+ * <em>Type</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getSquare
+ * <em>Square</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.PieceImpl#getBoard
+ * <em>Board</em>}</li>
  * </ul>
  * </p>
  *
@@ -51,8 +48,8 @@
 public class PieceImpl extends EObjectImpl implements Piece {
 	/**
 	 * The default value of the '{@link #getOwner() <em>Owner</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getOwner()
 	 * @generated
 	 * @ordered
@@ -61,8 +58,8 @@
 
 	/**
 	 * The cached value of the '{@link #getOwner() <em>Owner</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getOwner()
 	 * @generated
 	 * @ordered
@@ -71,8 +68,8 @@
 
 	/**
 	 * The default value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getType()
 	 * @generated
 	 * @ordered
@@ -81,8 +78,8 @@
 
 	/**
 	 * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getType()
 	 * @generated
 	 * @ordered
@@ -91,8 +88,8 @@
 
 	/**
 	 * The cached value of the '{@link #getSquare() <em>Square</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getSquare()
 	 * @generated
 	 * @ordered
@@ -100,8 +97,8 @@
 	protected Square square;
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	protected PieceImpl() {
@@ -109,8 +106,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
@@ -119,8 +116,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Colors getOwner() {
@@ -128,8 +125,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setOwner(Colors newOwner) {
@@ -140,8 +137,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Types getType() {
@@ -149,8 +146,8 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setType(Types newType) {
@@ -161,25 +158,26 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Square getSquare() {
 		if (square != null && square.eIsProxy()) {
-			InternalEObject oldSquare = (InternalEObject)square;
-			square = (Square)eResolveProxy(oldSquare);
+			InternalEObject oldSquare = (InternalEObject) square;
+			square = (Square) eResolveProxy(oldSquare);
 			if (square != oldSquare) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ChessPackage.PIECE__SQUARE, oldSquare, square));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ChessPackage.PIECE__SQUARE, oldSquare,
+							square));
 			}
 		}
 		return square;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Square basicGetSquare() {
@@ -187,227 +185,235 @@
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public NotificationChain basicSetSquare(Square newSquare, NotificationChain msgs) {
 		Square oldSquare = square;
 		square = newSquare;
 		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ChessPackage.PIECE__SQUARE, oldSquare, newSquare);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ChessPackage.PIECE__SQUARE,
+					oldSquare, newSquare);
+			if (msgs == null)
+				msgs = notification;
+			else
+				msgs.add(notification);
 		}
 		return msgs;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setSquare(Square newSquare) {
 		if (newSquare != square) {
 			NotificationChain msgs = null;
 			if (square != null)
-				msgs = ((InternalEObject)square).eInverseRemove(this, ChessPackage.SQUARE__PIECE, Square.class, msgs);
+				msgs = ((InternalEObject) square).eInverseRemove(this, ChessPackage.SQUARE__PIECE, Square.class, msgs);
 			if (newSquare != null)
-				msgs = ((InternalEObject)newSquare).eInverseAdd(this, ChessPackage.SQUARE__PIECE, Square.class, msgs);
+				msgs = ((InternalEObject) newSquare).eInverseAdd(this, ChessPackage.SQUARE__PIECE, Square.class, msgs);
 			msgs = basicSetSquare(newSquare, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
+			if (msgs != null)
+				msgs.dispatch();
+		} else if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, ChessPackage.PIECE__SQUARE, newSquare, newSquare));
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Board getBoard() {
-		if (eContainerFeatureID() != ChessPackage.PIECE__BOARD) return null;
-		return (Board)eContainer();
+		if (eContainerFeatureID() != ChessPackage.PIECE__BOARD)
+			return null;
+		return (Board) eContainer();
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public NotificationChain basicSetBoard(Board newBoard, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newBoard, ChessPackage.PIECE__BOARD, msgs);
+		msgs = eBasicSetContainer((InternalEObject) newBoard, ChessPackage.PIECE__BOARD, msgs);
 		return msgs;
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setBoard(Board newBoard) {
-		if (newBoard != eInternalContainer() || (eContainerFeatureID() != ChessPackage.PIECE__BOARD && newBoard != null)) {
+		if (newBoard != eInternalContainer()
+				|| (eContainerFeatureID() != ChessPackage.PIECE__BOARD && newBoard != null)) {
 			if (EcoreUtil.isAncestor(this, newBoard))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newBoard != null)
-				msgs = ((InternalEObject)newBoard).eInverseAdd(this, ChessPackage.BOARD__PIECES, Board.class, msgs);
+				msgs = ((InternalEObject) newBoard).eInverseAdd(this, ChessPackage.BOARD__PIECES, Board.class, msgs);
 			msgs = basicSetBoard(newBoard, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
+			if (msgs != null)
+				msgs.dispatch();
+		} else if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, ChessPackage.PIECE__BOARD, newBoard, newBoard));
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case ChessPackage.PIECE__SQUARE:
-				if (square != null)
-					msgs = ((InternalEObject)square).eInverseRemove(this, ChessPackage.SQUARE__PIECE, Square.class, msgs);
-				return basicSetSquare((Square)otherEnd, msgs);
-			case ChessPackage.PIECE__BOARD:
-				if (eInternalContainer() != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return basicSetBoard((Board)otherEnd, msgs);
+		case ChessPackage.PIECE__SQUARE:
+			if (square != null)
+				msgs = ((InternalEObject) square).eInverseRemove(this, ChessPackage.SQUARE__PIECE, Square.class, msgs);
+			return basicSetSquare((Square) otherEnd, msgs);
+		case ChessPackage.PIECE__BOARD:
+			if (eInternalContainer() != null)
+				msgs = eBasicRemoveFromContainer(msgs);
+			return basicSetBoard((Board) otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case ChessPackage.PIECE__SQUARE:
-				return basicSetSquare(null, msgs);
-			case ChessPackage.PIECE__BOARD:
-				return basicSetBoard(null, msgs);
+		case ChessPackage.PIECE__SQUARE:
+			return basicSetSquare(null, msgs);
+		case ChessPackage.PIECE__BOARD:
+			return basicSetBoard(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case ChessPackage.PIECE__BOARD:
-				return eInternalContainer().eInverseRemove(this, ChessPackage.BOARD__PIECES, Board.class, msgs);
+		case ChessPackage.PIECE__BOARD:
+			return eInternalContainer().eInverseRemove(this, ChessPackage.BOARD__PIECES, Board.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case ChessPackage.PIECE__OWNER:
-				return getOwner();
-			case ChessPackage.PIECE__TYPE:
-				return getType();
-			case ChessPackage.PIECE__SQUARE:
-				if (resolve) return getSquare();
-				return basicGetSquare();
-			case ChessPackage.PIECE__BOARD:
-				return getBoard();
+		case ChessPackage.PIECE__OWNER:
+			return getOwner();
+		case ChessPackage.PIECE__TYPE:
+			return getType();
+		case ChessPackage.PIECE__SQUARE:
+			if (resolve)
+				return getSquare();
+			return basicGetSquare();
+		case ChessPackage.PIECE__BOARD:
+			return getBoard();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case ChessPackage.PIECE__OWNER:
-				setOwner((Colors)newValue);
-				return;
-			case ChessPackage.PIECE__TYPE:
-				setType((Types)newValue);
-				return;
-			case ChessPackage.PIECE__SQUARE:
-				setSquare((Square)newValue);
-				return;
-			case ChessPackage.PIECE__BOARD:
-				setBoard((Board)newValue);
-				return;
+		case ChessPackage.PIECE__OWNER:
+			setOwner((Colors) newValue);
+			return;
+		case ChessPackage.PIECE__TYPE:
+			setType((Types) newValue);
+			return;
+		case ChessPackage.PIECE__SQUARE:
+			setSquare((Square) newValue);
+			return;
+		case ChessPackage.PIECE__BOARD:
+			setBoard((Board) newValue);
+			return;
 		}
 		super.eSet(featureID, newValue);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case ChessPackage.PIECE__OWNER:
-				setOwner(OWNER_EDEFAULT);
-				return;
-			case ChessPackage.PIECE__TYPE:
-				setType(TYPE_EDEFAULT);
-				return;
-			case ChessPackage.PIECE__SQUARE:
-				setSquare((Square)null);
-				return;
-			case ChessPackage.PIECE__BOARD:
-				setBoard((Board)null);
-				return;
+		case ChessPackage.PIECE__OWNER:
+			setOwner(OWNER_EDEFAULT);
+			return;
+		case ChessPackage.PIECE__TYPE:
+			setType(TYPE_EDEFAULT);
+			return;
+		case ChessPackage.PIECE__SQUARE:
+			setSquare((Square) null);
+			return;
+		case ChessPackage.PIECE__BOARD:
+			setBoard((Board) null);
+			return;
 		}
 		super.eUnset(featureID);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case ChessPackage.PIECE__OWNER:
-				return owner != OWNER_EDEFAULT;
-			case ChessPackage.PIECE__TYPE:
-				return type != TYPE_EDEFAULT;
-			case ChessPackage.PIECE__SQUARE:
-				return square != null;
-			case ChessPackage.PIECE__BOARD:
-				return getBoard() != null;
+		case ChessPackage.PIECE__OWNER:
+			return owner != OWNER_EDEFAULT;
+		case ChessPackage.PIECE__TYPE:
+			return type != TYPE_EDEFAULT;
+		case ChessPackage.PIECE__SQUARE:
+			return square != null;
+		case ChessPackage.PIECE__BOARD:
+			return getBoard() != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
 	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String toString() {
-		if (eIsProxy()) return super.toString();
+		if (eIsProxy())
+			return super.toString();
 
 		StringBuffer result = new StringBuffer(super.toString());
 		result.append(" (owner: ");
@@ -418,4 +424,4 @@
 		return result.toString();
 	}
 
-} //PieceImpl
+} // PieceImpl
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/SquareImpl.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/SquareImpl.java
index a6ed2bf..2e5a6b1 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/SquareImpl.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/impl/SquareImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.impl;
 
 import org.eclipse.emf.common.notify.Notification;
@@ -35,12 +33,18 @@
  * <p>
  * The following features are implemented:
  * <ul>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getBoard <em>Board</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getIndex <em>Index</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getFile <em>File</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getRank <em>Rank</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getColor <em>Color</em>}</li>
- *   <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getPiece <em>Piece</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getBoard
+ * <em>Board</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getIndex
+ * <em>Index</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getFile
+ * <em>File</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getRank
+ * <em>Rank</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getColor
+ * <em>Color</em>}</li>
+ * <li>{@link org.eclipse.graphiti.examples.mm.chess.impl.SquareImpl#getPiece
+ * <em>Piece</em>}</li>
  * </ul>
  * </p>
  *
@@ -50,6 +54,7 @@
 	/**
 	 * The default value of the '{@link #getIndex() <em>Index</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getIndex()
 	 * @generated
 	 * @ordered
@@ -58,6 +63,7 @@
 	/**
 	 * The cached value of the '{@link #getIndex() <em>Index</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getIndex()
 	 * @generated
 	 * @ordered
@@ -67,6 +73,7 @@
 	/**
 	 * The default value of the '{@link #getFile() <em>File</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getFile()
 	 * @generated
 	 * @ordered
@@ -75,6 +82,7 @@
 	/**
 	 * The cached value of the '{@link #getFile() <em>File</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getFile()
 	 * @generated
 	 * @ordered
@@ -83,6 +91,7 @@
 	/**
 	 * The default value of the '{@link #getRank() <em>Rank</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getRank()
 	 * @generated
 	 * @ordered
@@ -91,6 +100,7 @@
 	/**
 	 * The cached value of the '{@link #getRank() <em>Rank</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getRank()
 	 * @generated
 	 * @ordered
@@ -99,6 +109,7 @@
 	/**
 	 * The default value of the '{@link #getColor() <em>Color</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getColor()
 	 * @generated
 	 * @ordered
@@ -107,6 +118,7 @@
 	/**
 	 * The cached value of the '{@link #getColor() <em>Color</em>}' attribute.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getColor()
 	 * @generated
 	 * @ordered
@@ -115,6 +127,7 @@
 	/**
 	 * The cached value of the '{@link #getPiece() <em>Piece</em>}' reference.
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @see #getPiece()
 	 * @generated
 	 * @ordered
@@ -123,6 +136,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	protected SquareImpl() {
@@ -131,6 +145,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
@@ -140,44 +155,50 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Board getBoard() {
-		if (eContainerFeatureID() != ChessPackage.SQUARE__BOARD) return null;
-		return (Board)eContainer();
+		if (eContainerFeatureID() != ChessPackage.SQUARE__BOARD)
+			return null;
+		return (Board) eContainer();
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public NotificationChain basicSetBoard(Board newBoard, NotificationChain msgs) {
-		msgs = eBasicSetContainer((InternalEObject)newBoard, ChessPackage.SQUARE__BOARD, msgs);
+		msgs = eBasicSetContainer((InternalEObject) newBoard, ChessPackage.SQUARE__BOARD, msgs);
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setBoard(Board newBoard) {
-		if (newBoard != eInternalContainer() || (eContainerFeatureID() != ChessPackage.SQUARE__BOARD && newBoard != null)) {
+		if (newBoard != eInternalContainer()
+				|| (eContainerFeatureID() != ChessPackage.SQUARE__BOARD && newBoard != null)) {
 			if (EcoreUtil.isAncestor(this, newBoard))
 				throw new IllegalArgumentException("Recursive containment not allowed for " + toString());
 			NotificationChain msgs = null;
 			if (eInternalContainer() != null)
 				msgs = eBasicRemoveFromContainer(msgs);
 			if (newBoard != null)
-				msgs = ((InternalEObject)newBoard).eInverseAdd(this, ChessPackage.BOARD__SQUARES, Board.class, msgs);
+				msgs = ((InternalEObject) newBoard).eInverseAdd(this, ChessPackage.BOARD__SQUARES, Board.class, msgs);
 			msgs = basicSetBoard(newBoard, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
+			if (msgs != null)
+				msgs.dispatch();
+		} else if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, ChessPackage.SQUARE__BOARD, newBoard, newBoard));
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public int getIndex() {
@@ -186,6 +207,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setIndex(int newIndex) {
@@ -197,15 +219,17 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Piece getPiece() {
 		if (piece != null && piece.eIsProxy()) {
-			InternalEObject oldPiece = (InternalEObject)piece;
-			piece = (Piece)eResolveProxy(oldPiece);
+			InternalEObject oldPiece = (InternalEObject) piece;
+			piece = (Piece) eResolveProxy(oldPiece);
 			if (piece != oldPiece) {
 				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ChessPackage.SQUARE__PIECE, oldPiece, piece));
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ChessPackage.SQUARE__PIECE, oldPiece,
+							piece));
 			}
 		}
 		return piece;
@@ -213,6 +237,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Piece basicGetPiece() {
@@ -221,38 +246,45 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public NotificationChain basicSetPiece(Piece newPiece, NotificationChain msgs) {
 		Piece oldPiece = piece;
 		piece = newPiece;
 		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ChessPackage.SQUARE__PIECE, oldPiece, newPiece);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ChessPackage.SQUARE__PIECE,
+					oldPiece, newPiece);
+			if (msgs == null)
+				msgs = notification;
+			else
+				msgs.add(notification);
 		}
 		return msgs;
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setPiece(Piece newPiece) {
 		if (newPiece != piece) {
 			NotificationChain msgs = null;
 			if (piece != null)
-				msgs = ((InternalEObject)piece).eInverseRemove(this, ChessPackage.PIECE__SQUARE, Piece.class, msgs);
+				msgs = ((InternalEObject) piece).eInverseRemove(this, ChessPackage.PIECE__SQUARE, Piece.class, msgs);
 			if (newPiece != null)
-				msgs = ((InternalEObject)newPiece).eInverseAdd(this, ChessPackage.PIECE__SQUARE, Piece.class, msgs);
+				msgs = ((InternalEObject) newPiece).eInverseAdd(this, ChessPackage.PIECE__SQUARE, Piece.class, msgs);
 			msgs = basicSetPiece(newPiece, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else if (eNotificationRequired())
+			if (msgs != null)
+				msgs.dispatch();
+		} else if (eNotificationRequired())
 			eNotify(new ENotificationImpl(this, Notification.SET, ChessPackage.SQUARE__PIECE, newPiece, newPiece));
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Ranks getRank() {
@@ -261,6 +293,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setRank(Ranks newRank) {
@@ -272,6 +305,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Files getFile() {
@@ -280,6 +314,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setFile(Files newFile) {
@@ -291,6 +326,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public Colors getColor() {
@@ -299,6 +335,7 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public void setColor(Colors newColor) {
@@ -328,163 +365,173 @@
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case ChessPackage.SQUARE__BOARD:
-				if (eInternalContainer() != null)
-					msgs = eBasicRemoveFromContainer(msgs);
-				return basicSetBoard((Board)otherEnd, msgs);
-			case ChessPackage.SQUARE__PIECE:
-				if (piece != null)
-					msgs = ((InternalEObject)piece).eInverseRemove(this, ChessPackage.PIECE__SQUARE, Piece.class, msgs);
-				return basicSetPiece((Piece)otherEnd, msgs);
+		case ChessPackage.SQUARE__BOARD:
+			if (eInternalContainer() != null)
+				msgs = eBasicRemoveFromContainer(msgs);
+			return basicSetBoard((Board) otherEnd, msgs);
+		case ChessPackage.SQUARE__PIECE:
+			if (piece != null)
+				msgs = ((InternalEObject) piece).eInverseRemove(this, ChessPackage.PIECE__SQUARE, Piece.class, msgs);
+			return basicSetPiece((Piece) otherEnd, msgs);
 		}
 		return super.eInverseAdd(otherEnd, featureID, msgs);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
 		switch (featureID) {
-			case ChessPackage.SQUARE__BOARD:
-				return basicSetBoard(null, msgs);
-			case ChessPackage.SQUARE__PIECE:
-				return basicSetPiece(null, msgs);
+		case ChessPackage.SQUARE__BOARD:
+			return basicSetBoard(null, msgs);
+		case ChessPackage.SQUARE__PIECE:
+			return basicSetPiece(null, msgs);
 		}
 		return super.eInverseRemove(otherEnd, featureID, msgs);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
 		switch (eContainerFeatureID()) {
-			case ChessPackage.SQUARE__BOARD:
-				return eInternalContainer().eInverseRemove(this, ChessPackage.BOARD__SQUARES, Board.class, msgs);
+		case ChessPackage.SQUARE__BOARD:
+			return eInternalContainer().eInverseRemove(this, ChessPackage.BOARD__SQUARES, Board.class, msgs);
 		}
 		return super.eBasicRemoveFromContainerFeature(msgs);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public Object eGet(int featureID, boolean resolve, boolean coreType) {
 		switch (featureID) {
-			case ChessPackage.SQUARE__BOARD:
-				return getBoard();
-			case ChessPackage.SQUARE__INDEX:
-				return getIndex();
-			case ChessPackage.SQUARE__FILE:
-				return getFile();
-			case ChessPackage.SQUARE__RANK:
-				return getRank();
-			case ChessPackage.SQUARE__COLOR:
-				return getColor();
-			case ChessPackage.SQUARE__PIECE:
-				if (resolve) return getPiece();
-				return basicGetPiece();
+		case ChessPackage.SQUARE__BOARD:
+			return getBoard();
+		case ChessPackage.SQUARE__INDEX:
+			return getIndex();
+		case ChessPackage.SQUARE__FILE:
+			return getFile();
+		case ChessPackage.SQUARE__RANK:
+			return getRank();
+		case ChessPackage.SQUARE__COLOR:
+			return getColor();
+		case ChessPackage.SQUARE__PIECE:
+			if (resolve)
+				return getPiece();
+			return basicGetPiece();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public void eSet(int featureID, Object newValue) {
 		switch (featureID) {
-			case ChessPackage.SQUARE__BOARD:
-				setBoard((Board)newValue);
-				return;
-			case ChessPackage.SQUARE__INDEX:
-				setIndex((Integer)newValue);
-				return;
-			case ChessPackage.SQUARE__FILE:
-				setFile((Files)newValue);
-				return;
-			case ChessPackage.SQUARE__RANK:
-				setRank((Ranks)newValue);
-				return;
-			case ChessPackage.SQUARE__COLOR:
-				setColor((Colors)newValue);
-				return;
-			case ChessPackage.SQUARE__PIECE:
-				setPiece((Piece)newValue);
-				return;
+		case ChessPackage.SQUARE__BOARD:
+			setBoard((Board) newValue);
+			return;
+		case ChessPackage.SQUARE__INDEX:
+			setIndex((Integer) newValue);
+			return;
+		case ChessPackage.SQUARE__FILE:
+			setFile((Files) newValue);
+			return;
+		case ChessPackage.SQUARE__RANK:
+			setRank((Ranks) newValue);
+			return;
+		case ChessPackage.SQUARE__COLOR:
+			setColor((Colors) newValue);
+			return;
+		case ChessPackage.SQUARE__PIECE:
+			setPiece((Piece) newValue);
+			return;
 		}
 		super.eSet(featureID, newValue);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public void eUnset(int featureID) {
 		switch (featureID) {
-			case ChessPackage.SQUARE__BOARD:
-				setBoard((Board)null);
-				return;
-			case ChessPackage.SQUARE__INDEX:
-				setIndex(INDEX_EDEFAULT);
-				return;
-			case ChessPackage.SQUARE__FILE:
-				setFile(FILE_EDEFAULT);
-				return;
-			case ChessPackage.SQUARE__RANK:
-				setRank(RANK_EDEFAULT);
-				return;
-			case ChessPackage.SQUARE__COLOR:
-				setColor(COLOR_EDEFAULT);
-				return;
-			case ChessPackage.SQUARE__PIECE:
-				setPiece((Piece)null);
-				return;
+		case ChessPackage.SQUARE__BOARD:
+			setBoard((Board) null);
+			return;
+		case ChessPackage.SQUARE__INDEX:
+			setIndex(INDEX_EDEFAULT);
+			return;
+		case ChessPackage.SQUARE__FILE:
+			setFile(FILE_EDEFAULT);
+			return;
+		case ChessPackage.SQUARE__RANK:
+			setRank(RANK_EDEFAULT);
+			return;
+		case ChessPackage.SQUARE__COLOR:
+			setColor(COLOR_EDEFAULT);
+			return;
+		case ChessPackage.SQUARE__PIECE:
+			setPiece((Piece) null);
+			return;
 		}
 		super.eUnset(featureID);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public boolean eIsSet(int featureID) {
 		switch (featureID) {
-			case ChessPackage.SQUARE__BOARD:
-				return getBoard() != null;
-			case ChessPackage.SQUARE__INDEX:
-				return index != INDEX_EDEFAULT;
-			case ChessPackage.SQUARE__FILE:
-				return file != FILE_EDEFAULT;
-			case ChessPackage.SQUARE__RANK:
-				return rank != RANK_EDEFAULT;
-			case ChessPackage.SQUARE__COLOR:
-				return color != COLOR_EDEFAULT;
-			case ChessPackage.SQUARE__PIECE:
-				return piece != null;
+		case ChessPackage.SQUARE__BOARD:
+			return getBoard() != null;
+		case ChessPackage.SQUARE__INDEX:
+			return index != INDEX_EDEFAULT;
+		case ChessPackage.SQUARE__FILE:
+			return file != FILE_EDEFAULT;
+		case ChessPackage.SQUARE__RANK:
+			return rank != RANK_EDEFAULT;
+		case ChessPackage.SQUARE__COLOR:
+			return color != COLOR_EDEFAULT;
+		case ChessPackage.SQUARE__PIECE:
+			return piece != null;
 		}
 		return super.eIsSet(featureID);
 	}
 
 	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	@Override
 	public String toString() {
-		if (eIsProxy()) return super.toString();
+		if (eIsProxy())
+			return super.toString();
 
 		StringBuffer result = new StringBuffer(super.toString());
 		result.append(" (index: ");
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessAdapterFactory.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessAdapterFactory.java
index 5605787..ae7a1be 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessAdapterFactory.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessAdapterFactory.java
@@ -1,49 +1,46 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.util;
 
 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.Notifier;
-
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-
 import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.graphiti.examples.mm.chess.*;
+import org.eclipse.graphiti.examples.mm.chess.Board;
+import org.eclipse.graphiti.examples.mm.chess.ChessPackage;
+import org.eclipse.graphiti.examples.mm.chess.Piece;
+import org.eclipse.graphiti.examples.mm.chess.Square;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Adapter Factory</b> for the model.
- * It provides an adapter <code>createXXX</code> method for each class of the model.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Adapter Factory</b> for the model. It provides
+ * an adapter <code>createXXX</code> method for each class of the model. <!--
+ * end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage
  * @generated
  */
 public class ChessAdapterFactory extends AdapterFactoryImpl {
 	/**
-	 * The cached model package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The cached model package. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	protected static ChessPackage modelPackage;
 
 	/**
-	 * Creates an instance of the adapter factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Creates an instance of the adapter factory. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public ChessAdapterFactory() {
@@ -54,9 +51,10 @@
 
 	/**
 	 * Returns whether this factory is applicable for the type of the object.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
-	 * <!-- end-user-doc -->
+	 * <!-- begin-user-doc --> This implementation returns <code>true</code> if
+	 * the object is either the model's package or is an instance object of the
+	 * model. <!-- end-user-doc -->
+	 * 
 	 * @return whether this factory is applicable for the type of the object.
 	 * @generated
 	 */
@@ -66,57 +64,60 @@
 			return true;
 		}
 		if (object instanceof EObject) {
-			return ((EObject)object).eClass().getEPackage() == modelPackage;
+			return ((EObject) object).eClass().getEPackage() == modelPackage;
 		}
 		return false;
 	}
 
 	/**
-	 * The switch that delegates to the <code>createXXX</code> methods.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The switch that delegates to the <code>createXXX</code> methods. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
-	protected ChessSwitch<Adapter> modelSwitch =
-		new ChessSwitch<Adapter>() {
-			@Override
-			public Adapter caseBoard(Board object) {
-				return createBoardAdapter();
-			}
-			@Override
-			public Adapter caseSquare(Square object) {
-				return createSquareAdapter();
-			}
-			@Override
-			public Adapter casePiece(Piece object) {
-				return createPieceAdapter();
-			}
-			@Override
-			public Adapter defaultCase(EObject object) {
-				return createEObjectAdapter();
-			}
-		};
+	protected ChessSwitch<Adapter> modelSwitch = new ChessSwitch<Adapter>() {
+		@Override
+		public Adapter caseBoard(Board object) {
+			return createBoardAdapter();
+		}
+
+		@Override
+		public Adapter caseSquare(Square object) {
+			return createSquareAdapter();
+		}
+
+		@Override
+		public Adapter casePiece(Piece object) {
+			return createPieceAdapter();
+		}
+
+		@Override
+		public Adapter defaultCase(EObject object) {
+			return createEObjectAdapter();
+		}
+	};
 
 	/**
-	 * Creates an adapter for the <code>target</code>.
-	 * <!-- begin-user-doc -->
+	 * Creates an adapter for the <code>target</code>. <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @param target the object to adapt.
+	 * 
+	 * @param target
+	 *            the object to adapt.
 	 * @return the adapter for the <code>target</code>.
 	 * @generated
 	 */
 	@Override
 	public Adapter createAdapter(Notifier target) {
-		return modelSwitch.doSwitch((EObject)target);
+		return modelSwitch.doSwitch((EObject) target);
 	}
 
-
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.graphiti.examples.mm.chess.Board <em>Board</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
+	 * Creates a new adapter for an object of class
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Board <em>Board</em>}'.
+	 * <!-- begin-user-doc --> This default implementation returns null so that
+	 * we can easily ignore cases; it's useful to ignore a case when inheritance
+	 * will catch all the cases anyway. <!-- end-user-doc -->
+	 * 
 	 * @return the new adapter.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Board
 	 * @generated
@@ -126,11 +127,12 @@
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.graphiti.examples.mm.chess.Square <em>Square</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
+	 * Creates a new adapter for an object of class
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Square <em>Square</em>}'.
+	 * <!-- begin-user-doc --> This default implementation returns null so that
+	 * we can easily ignore cases; it's useful to ignore a case when inheritance
+	 * will catch all the cases anyway. <!-- end-user-doc -->
+	 * 
 	 * @return the new adapter.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Square
 	 * @generated
@@ -140,11 +142,12 @@
 	}
 
 	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.graphiti.examples.mm.chess.Piece <em>Piece</em>}'.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null so that we can easily ignore cases;
-	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
-	 * <!-- end-user-doc -->
+	 * Creates a new adapter for an object of class
+	 * '{@link org.eclipse.graphiti.examples.mm.chess.Piece <em>Piece</em>}'.
+	 * <!-- begin-user-doc --> This default implementation returns null so that
+	 * we can easily ignore cases; it's useful to ignore a case when inheritance
+	 * will catch all the cases anyway. <!-- end-user-doc -->
+	 * 
 	 * @return the new adapter.
 	 * @see org.eclipse.graphiti.examples.mm.chess.Piece
 	 * @generated
@@ -154,10 +157,9 @@
 	}
 
 	/**
-	 * Creates a new adapter for the default case.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null.
-	 * <!-- end-user-doc -->
+	 * Creates a new adapter for the default case. <!-- begin-user-doc --> This
+	 * default implementation returns null. <!-- end-user-doc -->
+	 * 
 	 * @return the new adapter.
 	 * @generated
 	 */
@@ -165,4 +167,4 @@
 		return null;
 	}
 
-} //ChessAdapterFactory
+} // ChessAdapterFactory
diff --git a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessSwitch.java b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessSwitch.java
index 9f708da..c488ad0 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessSwitch.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src-gen/org/eclipse/graphiti/examples/mm/chess/util/ChessSwitch.java
@@ -1,52 +1,48 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.chess.util;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
-
 import org.eclipse.emf.ecore.util.Switch;
-
-import org.eclipse.graphiti.examples.mm.chess.*;
+import org.eclipse.graphiti.examples.mm.chess.Board;
+import org.eclipse.graphiti.examples.mm.chess.ChessPackage;
+import org.eclipse.graphiti.examples.mm.chess.Piece;
+import org.eclipse.graphiti.examples.mm.chess.Square;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Switch</b> for the model's inheritance hierarchy.
- * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance
+ * hierarchy. It supports the call {@link #doSwitch(EObject) doSwitch(object)}
  * to invoke the <code>caseXXX</code> method for each class of the model,
- * starting with the actual class of the object
- * and proceeding up the inheritance hierarchy
- * until a non-null result is returned,
- * which is the result of the switch.
- * <!-- end-user-doc -->
+ * starting with the actual class of the object and proceeding up the
+ * inheritance hierarchy until a non-null result is returned, which is the
+ * result of the switch. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.graphiti.examples.mm.chess.ChessPackage
  * @generated
  */
 public class ChessSwitch<T> extends Switch<T> {
 	/**
-	 * The cached model package
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	protected static ChessPackage modelPackage;
 
 	/**
-	 * Creates an instance of the switch.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Creates an instance of the switch. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
 	 * @generated
 	 */
 	public ChessSwitch() {
@@ -56,9 +52,9 @@
 	}
 
 	/**
-	 * Checks whether this is a switch for the given package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+	 * Checks whether this is a switch for the given package. <!--
+	 * begin-user-doc --> <!-- end-user-doc -->
+	 * 
 	 * @parameter ePackage the package in question.
 	 * @return whether this is a switch for the given package.
 	 * @generated
@@ -69,45 +65,53 @@
 	}
 
 	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * Calls <code>caseXXX</code> for each class of the model until one returns
+	 * a non null result; it yields that result. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
+	 * @return the first non-null result returned by a <code>caseXXX</code>
+	 *         call.
 	 * @generated
 	 */
 	@Override
 	protected T doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
-			case ChessPackage.BOARD: {
-				Board board = (Board)theEObject;
-				T result = caseBoard(board);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ChessPackage.SQUARE: {
-				Square square = (Square)theEObject;
-				T result = caseSquare(square);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ChessPackage.PIECE: {
-				Piece piece = (Piece)theEObject;
-				T result = casePiece(piece);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			default: return defaultCase(theEObject);
+		case ChessPackage.BOARD: {
+			Board board = (Board) theEObject;
+			T result = caseBoard(board);
+			if (result == null)
+				result = defaultCase(theEObject);
+			return result;
+		}
+		case ChessPackage.SQUARE: {
+			Square square = (Square) theEObject;
+			T result = caseSquare(square);
+			if (result == null)
+				result = defaultCase(theEObject);
+			return result;
+		}
+		case ChessPackage.PIECE: {
+			Piece piece = (Piece) theEObject;
+			T result = casePiece(piece);
+			if (result == null)
+				result = defaultCase(theEObject);
+			return result;
+		}
+		default:
+			return defaultCase(theEObject);
 		}
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Board</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Board</em>'.
+	 * Returns the result of interpreting the object as an instance of
+	 * '<em>Board</em>'. <!-- begin-user-doc --> This implementation returns
+	 * null; returning a non-null result will terminate the switch. <!--
+	 * end-user-doc -->
+	 * 
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of
+	 *         '<em>Board</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
@@ -116,13 +120,15 @@
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Square</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Square</em>'.
+	 * Returns the result of interpreting the object as an instance of
+	 * '<em>Square</em>'. <!-- begin-user-doc --> This implementation returns
+	 * null; returning a non-null result will terminate the switch. <!--
+	 * end-user-doc -->
+	 * 
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of
+	 *         '<em>Square</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
@@ -131,13 +137,15 @@
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Piece</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>Piece</em>'.
+	 * Returns the result of interpreting the object as an instance of
+	 * '<em>Piece</em>'. <!-- begin-user-doc --> This implementation returns
+	 * null; returning a non-null result will terminate the switch. <!--
+	 * end-user-doc -->
+	 * 
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of
+	 *         '<em>Piece</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
 	 * @generated
 	 */
@@ -146,13 +154,15 @@
 	}
 
 	/**
-	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch, but this is the last case anyway.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * Returns the result of interpreting the object as an instance of
+	 * '<em>EObject</em>'. <!-- begin-user-doc --> This implementation returns
+	 * null; returning a non-null result will terminate the switch, but this is
+	 * the last case anyway. <!-- end-user-doc -->
+	 * 
+	 * @param object
+	 *            the target of the switch.
+	 * @return the result of interpreting the object as an instance of
+	 *         '<em>EObject</em>'.
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
 	 */
@@ -161,4 +171,4 @@
 		return null;
 	}
 
-} //ChessSwitch
+} // ChessSwitch
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Activator.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Activator.java
index 5792542..4c5de8f 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Activator.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Activator.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess;
 
 import org.eclipse.ui.plugin.AbstractUIPlugin;
@@ -27,7 +25,7 @@
 
 	// The shared instance
 	private static Activator plugin;
-	
+
 	/**
 	 * The constructor
 	 */
@@ -36,7 +34,9 @@
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
+	 * 
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.
+	 * BundleContext)
 	 */
 	public void start(BundleContext context) throws Exception {
 		super.start(context);
@@ -45,7 +45,9 @@
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
+	 * 
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.
+	 * BundleContext)
 	 */
 	public void stop(BundleContext context) throws Exception {
 		plugin = null;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Messages.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Messages.java
index 5ae29b8..a4765f6 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Messages.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/Messages.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess;
 
 import org.eclipse.osgi.util.NLS;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/MoveUtil.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/MoveUtil.java
index 7bc59c6..536a079 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/MoveUtil.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/MoveUtil.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess;
 
 import org.eclipse.graphiti.examples.mm.chess.Board;
@@ -47,9 +44,8 @@
 			if (fileSteps == 0) {
 				// White pawns move upwards to higher ranks
 				if (Colors.LIGHT.equals(piece.getOwner())) {
-					if (rankSteps == 1
-							|| (rankSteps == 2 && Ranks.TWO.equals(sourceSquare.getRank()) && sourceSquare.getBoard()
-									.getSquare(Ranks.THREE, sourceSquare.getFile()).getPiece() == null)) {
+					if (rankSteps == 1 || (rankSteps == 2 && Ranks.TWO.equals(sourceSquare.getRank()) && sourceSquare
+							.getBoard().getSquare(Ranks.THREE, sourceSquare.getFile()).getPiece() == null)) {
 						// Allow to move 1 to front or 2 to front in case of
 						// start position
 						return targetSquare.getPiece() == null;
@@ -58,8 +54,8 @@
 				// Black pawns move downwards to lower ranks
 				else {
 					if (rankSteps == -1
-							|| (rankSteps == -2 && Ranks.SEVEN.equals(sourceSquare.getRank()) && sourceSquare
-									.getBoard().getSquare(Ranks.SIX, sourceSquare.getFile()).getPiece() == null)) {
+							|| (rankSteps == -2 && Ranks.SEVEN.equals(sourceSquare.getRank()) && sourceSquare.getBoard()
+									.getSquare(Ranks.SIX, sourceSquare.getFile()).getPiece() == null)) {
 						// Allow to move 1 to front or 2 to front in case of
 						// start position
 						return targetSquare.getPiece() == null;
@@ -178,8 +174,10 @@
 			// Check if any square in between is occupied, if yes the move is
 			// not allowed
 			for (int i = 1; i < toRank - fromRank; i++) {
-				if (board.getSquare(Ranks.get(fromRank + i),
-						Files.get(sourceSquare.getFile().getValue() + (i * fileDirection))).getPiece() != null) {
+				if (board
+						.getSquare(Ranks.get(fromRank + i),
+								Files.get(sourceSquare.getFile().getValue() + (i * fileDirection)))
+						.getPiece() != null) {
 					// Move over occupied square
 					return false;
 				}
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessDiagramTypeProvider.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessDiagramTypeProvider.java
index 25c4cd7..c51ad76 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessDiagramTypeProvider.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessDiagramTypeProvider.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.diagram;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessFeatureProvider.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessFeatureProvider.java
index 9e81fa4..5139147 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessFeatureProvider.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessFeatureProvider.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.diagram;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessToolBehaviorProvider.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessToolBehaviorProvider.java
index 0d8d078..4e86f62 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessToolBehaviorProvider.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/diagram/ChessToolBehaviorProvider.java
@@ -1,19 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.diagram;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessBoardFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessBoardFeature.java
index 6a5e0eb..ecdca19 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessBoardFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessBoardFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import org.eclipse.graphiti.examples.mm.chess.Board;
@@ -91,8 +89,8 @@
 			// Display file names at bottom
 			text = createService.createText(outerRectangle);
 			setLayoutForBorderTexts(layoutService, text);
-			layoutService.setLocationAndSize(text, FRAME_WIDTH + (file.getValue() - 1) * SQUARE_SIZE, FRAME_HEIGHT
-					+ BOARD_SIZE, SQUARE_SIZE, FRAME_HEIGHT);
+			layoutService.setLocationAndSize(text, FRAME_WIDTH + (file.getValue() - 1) * SQUARE_SIZE,
+					FRAME_HEIGHT + BOARD_SIZE, SQUARE_SIZE, FRAME_HEIGHT);
 			text.setValue(file.getLiteral());
 		}
 		for (Ranks rank : Ranks.values()) {
@@ -110,8 +108,8 @@
 			// Display rank names at right side
 			text = createService.createText(outerRectangle);
 			setLayoutForBorderTexts(layoutService, text);
-			layoutService.setLocationAndSize(text, FRAME_WIDTH + BOARD_SIZE, FRAME_WIDTH + (8 - rank.getValue())
-					* SQUARE_SIZE, FRAME_WIDTH, SQUARE_SIZE);
+			layoutService.setLocationAndSize(text, FRAME_WIDTH + BOARD_SIZE,
+					FRAME_WIDTH + (8 - rank.getValue()) * SQUARE_SIZE, FRAME_WIDTH, SQUARE_SIZE);
 			text.setValue(Integer.toString(rank.getValue()));
 		}
 
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessMoveFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessMoveFeature.java
index 0bf0984..dde548b 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessMoveFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessMoveFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import org.eclipse.graphiti.examples.chess.MoveUtil;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessPieceFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessPieceFeature.java
index 249e79d..2096591 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessPieceFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/AddChessPieceFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import org.eclipse.graphiti.examples.mm.chess.Colors;
@@ -60,17 +58,17 @@
 			points = new int[] { 10, 45, 15, 40, 10, 35, 5, 25, 5, 5, 10, 15, 15, 5, 20, 15, 25, 5, 30, 15, 35, 5, 40,
 					15, 45, 5, 45, 25, 40, 35, 35, 40, 40, 45 };
 		} else if (Types.KNIGHT.equals(piece.getType())) {
-			points = new int[] { 20, 45, 25, 35, 20, 25, 10, 35, 5, 30, 5, 25, 10, 15, 15, 10, 15, 5, 20, 10, 25, 5,
-					25, 10, 35, 15, 40, 20, 45, 30, 45, 45 };
+			points = new int[] { 20, 45, 25, 35, 20, 25, 10, 35, 5, 30, 5, 25, 10, 15, 15, 10, 15, 5, 20, 10, 25, 5, 25,
+					10, 35, 15, 40, 20, 45, 30, 45, 45 };
 		} else if (Types.PAWN.equals(piece.getType())) {
-			points = new int[] { 15, 45, 15, 40, 20, 30, 15, 25, 20, 20, 20, 15, 25, 10, 30, 15, 30, 20, 35, 25, 30,
-					30, 35, 40, 35, 45 };
+			points = new int[] { 15, 45, 15, 40, 20, 30, 15, 25, 20, 20, 20, 15, 25, 10, 30, 15, 30, 20, 35, 25, 30, 30,
+					35, 40, 35, 45 };
 		} else if (Types.QUEEN.equals(piece.getType())) {
 			points = new int[] { 10, 45, 15, 40, 10, 35, 5, 25, 5, 15, 10, 10, 15, 10, 20, 15, 25, 5, 30, 15, 35, 10,
 					40, 10, 45, 15, 45, 25, 40, 35, 35, 40, 40, 45 };
 		} else if (Types.ROOK.equals(piece.getType())) {
-			points = new int[] { 10, 45, 10, 40, 15, 30, 15, 15, 10, 10, 10, 5, 15, 5, 15, 10, 20, 10, 20, 5, 30, 5,
-					30, 10, 35, 10, 35, 5, 40, 5, 40, 10, 35, 15, 35, 30, 40, 40, 40, 45 };
+			points = new int[] { 10, 45, 10, 40, 15, 30, 15, 15, 10, 10, 10, 5, 15, 5, 15, 10, 20, 10, 20, 5, 30, 5, 30,
+					10, 35, 10, 35, 5, 40, 5, 40, 10, 35, 15, 35, 30, 40, 40, 40, 45 };
 		}
 
 		// Create the visualization of the board as a square
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateAllInitialChessPiecesFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateAllInitialChessPiecesFeature.java
index 8383864..922403a 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateAllInitialChessPiecesFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateAllInitialChessPiecesFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import java.util.ArrayList;
@@ -123,8 +121,8 @@
 
 					// Delegate to the add feature
 					AddContext addContext = new AddContext(context, piece);
-					List<PictogramElement> pictogramElements = Graphiti.getLinkService().getPictogramElements(
-							getDiagram(), square);
+					List<PictogramElement> pictogramElements = Graphiti.getLinkService()
+							.getPictogramElements(getDiagram(), square);
 					if (pictogramElements.size() > 0) {
 						addContext.setTargetContainer((ContainerShape) pictogramElements.get(0));
 						addGraphicalRepresentation(addContext, piece);
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessBoardFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessBoardFeature.java
index a4ed953..910430a 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessBoardFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessBoardFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import org.eclipse.emf.ecore.resource.Resource;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessMoveFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessMoveFeature.java
index af7db3b..93b7909 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessMoveFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/CreateChessMoveFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/MoveChessPieceFeature.java b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/MoveChessPieceFeature.java
index a85cbe3..40d45d5 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/MoveChessPieceFeature.java
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/features/MoveChessPieceFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.chess.features;
 
 import org.eclipse.graphiti.examples.chess.MoveUtil;
diff --git a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/messages.properties b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/messages.properties
index dcfdca7..5c0aa24 100644
--- a/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/messages.properties
+++ b/examples/org.eclipse.graphiti.examples.chess/src/org/eclipse/graphiti/examples/chess/messages.properties
@@ -1,3 +1,16 @@
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
+
 CreateAllInitialChessPiecesFeature_name=Create Pieces
 CreateAllInitialChessPiecesFeature_description=Create the initial set of pieces
 CreateChessBoardFeature_name=Create Board
diff --git a/examples/org.eclipse.graphiti.examples.common/about.html b/examples/org.eclipse.graphiti.examples.common/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.examples.common/about.html
+++ b/examples/org.eclipse.graphiti.examples.common/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.examples.common/build.properties b/examples/org.eclipse.graphiti.examples.common/build.properties
index b2e3a07..22c8724 100644
--- a/examples/org.eclipse.graphiti.examples.common/build.properties
+++ b/examples/org.eclipse.graphiti.examples.common/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/examples/org.eclipse.graphiti.examples.common/plugin.properties b/examples/org.eclipse.graphiti.examples.common/plugin.properties
index 65b094b..f07ff73 100644
--- a/examples/org.eclipse.graphiti.examples.common/plugin.properties
+++ b/examples/org.eclipse.graphiti.examples.common/plugin.properties
@@ -1,21 +1,18 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2015 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
 #    mwenz - Bug 418409 - Graphiti new project and new diagram wizards have disappeared from toolbar new entry
 #    mwenz - Bug 423018 - Direct Graphiti diagram exporter
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Examples Common (Incubation)
 providerName = Eclipse Modeling Project 
 
diff --git a/examples/org.eclipse.graphiti.examples.common/plugin.xml b/examples/org.eclipse.graphiti.examples.common/plugin.xml
index 7d8af64..3e0f17f 100644
--- a/examples/org.eclipse.graphiti.examples.common/plugin.xml
+++ b/examples/org.eclipse.graphiti.examples.common/plugin.xml
@@ -1,22 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2015 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
-       mwenz - Bug 418409 - Graphiti new project and new diagram wizards have disappeared from toolbar new entry
-       mwenz - Bug 423018 - Direct Graphiti diagram exporter
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/examples/org.eclipse.graphiti.examples.common/pom.xml b/examples/org.eclipse.graphiti.examples.common/pom.xml
index 27e3777..ff52ae8 100644
--- a/examples/org.eclipse.graphiti.examples.common/pom.xml
+++ b/examples/org.eclipse.graphiti.examples.common/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ColoredFont.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ColoredFont.java
index 7866916..613f3b9 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ColoredFont.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ColoredFont.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleImageProvider.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleImageProvider.java
index 7e04022..23c89dc 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleImageProvider.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleImageProvider.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import org.eclipse.graphiti.ui.platform.AbstractImageProvider;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleProjectNature.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleProjectNature.java
index d0a45c7..23d06b5 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleProjectNature.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleProjectNature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import org.eclipse.core.resources.IProject;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleUtil.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleUtil.java
index e99bcc8..2adfcbb 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleUtil.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExampleUtil.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExamplesCommonPlugin.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExamplesCommonPlugin.java
index 58870e3..ebe4380 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExamplesCommonPlugin.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ExamplesCommonPlugin.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import java.net.URL;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/FileService.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/FileService.java
index f09ba27..8b87b3a 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/FileService.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/FileService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import java.io.IOException;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/IExampleImageConstants.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/IExampleImageConstants.java
index ef4d1c6..4ac85b5 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/IExampleImageConstants.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/IExampleImageConstants.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 /**
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/Messages.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/Messages.java
index fddfd76..1d77ac2 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/Messages.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/Messages.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
- *    mwenz - Bug 460019 - Problem with CreateDiagramWizard_ErrorOccuredTitle
- *    mwenz - Bug 423018 - Direct Graphiti diagram exporter
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
+*    mwenz - Bug 460019 - Problem with CreateDiagramWizard_ErrorOccuredTitle
+*    mwenz - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import org.eclipse.osgi.util.NLS;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/RenameActionProvider.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/RenameActionProvider.java
index 057919d..6786f88 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/RenameActionProvider.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/RenameActionProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 505659 - NullPointerException below RenameActionProvider.fillContextMenu
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 505659 - NullPointerException below RenameActionProvider.fillContextMenu
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common;
 
 import java.io.IOException;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/OpenDiagramEditorFromFileHandler.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/OpenDiagramEditorFromFileHandler.java
index 0f9b922..71037ba 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/OpenDiagramEditorFromFileHandler.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/OpenDiagramEditorFromFileHandler.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.handler;
 
 import org.eclipse.core.commands.AbstractHandler;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/SaveDiagramAsImageHandler.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/SaveDiagramAsImageHandler.java
index 6e92cf2..666b9c0 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/SaveDiagramAsImageHandler.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/handler/SaveDiagramAsImageHandler.java
@@ -1,18 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015, 2015 SAP AG.
- * 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:
- *    mwenz - Bug 423018 - Direct Graphiti diagram exporter
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.handler;
 
 import java.io.FileNotFoundException;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/messages.properties b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/messages.properties
index 632e37e..6d8b7f2 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/messages.properties
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/messages.properties
@@ -1,3 +1,16 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
+
 CompartmentPattern_CompartmentChangesText=compartment changes
 CreateDiagramWizard_DiagramNameField=Diagram Name
 CreateDiagramWizard_DiagramTypeField=Diagram Type
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/EditorLinkHelper.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/EditorLinkHelper.java
index b1c353f..6bf5fa0 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/EditorLinkHelper.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/EditorLinkHelper.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator;
 
 import org.eclipse.core.resources.IFile;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfLabelProvider.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfLabelProvider.java
index fa2055a..168f108 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfLabelProvider.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfLabelProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator;
 
 import org.eclipse.core.resources.IFile;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfTreeContentProvider.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfTreeContentProvider.java
index 3921146..8f96762 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfTreeContentProvider.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/GFEmfTreeContentProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator;
 
 import java.util.HashMap;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/EClassesNode.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/EClassesNode.java
index 0d5adca..72b0750 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/EClassesNode.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/EClassesNode.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator.nodes;
 
 import org.eclipse.core.resources.IProject;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractContainerNode.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractContainerNode.java
index 5883e8b..5e33076 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractContainerNode.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractContainerNode.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 09.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator.nodes.base;
 
 import org.eclipse.swt.graphics.Image;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractInstancesOfTypeContainerNode.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractInstancesOfTypeContainerNode.java
index 81a39eb..8861440 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractInstancesOfTypeContainerNode.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/AbstractInstancesOfTypeContainerNode.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 13.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator.nodes.base;
 
 import org.eclipse.core.resources.IProject;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/IContainerNode.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/IContainerNode.java
index d089e78..edeefae 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/IContainerNode.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/navigator/nodes/base/IContainerNode.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 09.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.navigator.nodes.base;
 
 import org.eclipse.swt.graphics.Image;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/ContentOutlinePageAdapterFactory.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/ContentOutlinePageAdapterFactory.java
index dc3ecac..1a44219 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/ContentOutlinePageAdapterFactory.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/ContentOutlinePageAdapterFactory.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline;
 
 import org.eclipse.core.runtime.IAdapterFactory;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/GraphicsEditorOutlinePage.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/GraphicsEditorOutlinePage.java
index 364c283..ec61947 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/GraphicsEditorOutlinePage.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/GraphicsEditorOutlinePage.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline;
 
 import org.eclipse.draw2d.LightweightSystem;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/AbstractGraphicsTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/AbstractGraphicsTreeEditPart.java
index beb965d..5b5a0da 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/AbstractGraphicsTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/AbstractGraphicsTreeEditPart.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 28.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import java.lang.reflect.Array;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ColorTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ColorTreeEditPart.java
index f4993a7..bcd987a 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ColorTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ColorTreeEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ConnectionDecoratorTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ConnectionDecoratorTreeEditPart.java
index 950286b..e2a8883 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ConnectionDecoratorTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/ConnectionDecoratorTreeEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/GraphicsAlgorithmTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/GraphicsAlgorithmTreeEditPart.java
index c9d42e1..d279e29 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/GraphicsAlgorithmTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/GraphicsAlgorithmTreeEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramElementTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramElementTreeEditPart.java
index c365da4..f2f6374 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramElementTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramElementTreeEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramsTreeEditPartFactory.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramsTreeEditPartFactory.java
index 035e565..69845db 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramsTreeEditPartFactory.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PictogramsTreeEditPartFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import org.eclipse.gef.EditPart;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PointTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PointTreeEditPart.java
index 3b01656..dca904e 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PointTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/PointTreeEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/StyleTreeEditPart.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/StyleTreeEditPart.java
index 05ed420..e27f840 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/StyleTreeEditPart.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/outline/tree/StyleTreeEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.outline.tree;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/CompartmentPattern.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/CompartmentPattern.java
index 7019430..0c5434f 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/CompartmentPattern.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/CompartmentPattern.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.pattern.compartment;
 
 import java.util.List;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/DefaultCompartmentPatternConfiguration.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/DefaultCompartmentPatternConfiguration.java
index 34e8a79..9b9fb82 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/DefaultCompartmentPatternConfiguration.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/DefaultCompartmentPatternConfiguration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.pattern.compartment;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/ICompartmentPatternConfiguration.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/ICompartmentPatternConfiguration.java
index ba6f48c..62c7e68 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/ICompartmentPatternConfiguration.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/compartment/ICompartmentPatternConfiguration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.pattern.compartment;
 
 import org.eclipse.graphiti.pattern.config.IColorConfiguration;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/DefaultGridPatternConfiguration.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/DefaultGridPatternConfiguration.java
index fbfd8a5..129c2dc 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/DefaultGridPatternConfiguration.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/DefaultGridPatternConfiguration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.pattern.grid;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/GridPattern.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/GridPattern.java
index c2721e8..ebacd08 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/GridPattern.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/GridPattern.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.pattern.grid;
 
 import java.util.List;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/IGridPatternConfiguration.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/IGridPatternConfiguration.java
index 2042686..1a30a64 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/IGridPatternConfiguration.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/pattern/grid/IGridPatternConfiguration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.pattern.grid;
 
 import org.eclipse.graphiti.pattern.config.IColorConfiguration;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/perspective/GFPerspective.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/perspective/GFPerspective.java
index 4c99778..2595df2 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/perspective/GFPerspective.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/perspective/GFPerspective.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.perspective;
 
 import org.eclipse.graphiti.ui.internal.editor.ThumbNailView;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/preference/GraphicsTestPreferencePage.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/preference/GraphicsTestPreferencePage.java
index 8920990..5d9217d 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/preference/GraphicsTestPreferencePage.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/preference/GraphicsTestPreferencePage.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.preference;
 
 import org.eclipse.core.runtime.preferences.InstanceScope;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/PropertiesLabelProvider.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/PropertiesLabelProvider.java
index b881513..c8ae43b 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/PropertiesLabelProvider.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/PropertiesLabelProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.property;
 
 import java.util.Iterator;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/TypeMapper.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/TypeMapper.java
index e785c2c..4722bff 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/TypeMapper.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/property/TypeMapper.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.property;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/AbstractWizardPage.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/AbstractWizardPage.java
index 35f9adf..349275c 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/AbstractWizardPage.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/AbstractWizardPage.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.ui;
 
 import org.eclipse.jface.resource.ImageDescriptor;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateDiagramWizard.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateDiagramWizard.java
index 717acb5..1b32214 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateDiagramWizard.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateDiagramWizard.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 460019 - Problem with CreateDiagramWizard_ErrorOccuredTitle
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 460019 - Problem with CreateDiagramWizard_ErrorOccuredTitle
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.ui;
 
 import org.eclipse.core.resources.IFile;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateSampleProjectWizard.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateSampleProjectWizard.java
index da63878..798fd07 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateSampleProjectWizard.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/CreateSampleProjectWizard.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.ui;
 
 import java.io.IOException;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramNameWizardPage.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramNameWizardPage.java
index 55a96ba..3ac6c91 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramNameWizardPage.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramNameWizardPage.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.ui;
 
 import org.eclipse.core.resources.IResource;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramTypeWizardPage.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramTypeWizardPage.java
index ad177e8..5267ea9 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramTypeWizardPage.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/DiagramTypeWizardPage.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.ui;
 
 import java.util.Arrays;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/ITextProvider.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/ITextProvider.java
index 33b3f4a..9c37141 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/ITextProvider.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/ui/ITextProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.ui;
 
 interface ITextProvider {
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/T.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/T.java
index c6d939c..6e99450 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/T.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/T.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2016, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2016, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.util;
 
 import org.eclipse.graphiti.examples.common.ExamplesCommonPlugin;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/Util.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/Util.java
index f53698d..ed2b76c 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/Util.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/Util.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 345442 - Fixed NPE in RenameActionProvider.fillContextMenu (EClasses were proxies right after loading)
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 495984 - PackageNotFoundException below Util.getAllClasses
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 345442 - Fixed NPE in RenameActionProvider.fillContextMenu (EClasses were proxies right after loading)
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 495984 - PackageNotFoundException below Util.getAllClasses
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.util;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/uiprovider/TwoObjectsContainer.java b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/uiprovider/TwoObjectsContainer.java
index 2cf30bf..df4244c 100644
--- a/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/uiprovider/TwoObjectsContainer.java
+++ b/examples/org.eclipse.graphiti.examples.common/src/org/eclipse/graphiti/examples/common/util/uiprovider/TwoObjectsContainer.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.common.util.uiprovider;
 
 import org.eclipse.graphiti.examples.common.util.Util;
diff --git a/examples/org.eclipse.graphiti.examples.composite/about.html b/examples/org.eclipse.graphiti.examples.composite/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.examples.composite/about.html
+++ b/examples/org.eclipse.graphiti.examples.composite/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.examples.composite/build.properties b/examples/org.eclipse.graphiti.examples.composite/build.properties
index f037b73..57bca61 100644
--- a/examples/org.eclipse.graphiti.examples.composite/build.properties
+++ b/examples/org.eclipse.graphiti.examples.composite/build.properties
@@ -1,3 +1,16 @@
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
+# Contributors:
+#    SAP SE - initial API, implementation and documentation
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
+
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/examples/org.eclipse.graphiti.examples.composite/plugin.properties b/examples/org.eclipse.graphiti.examples.composite/plugin.properties
index 550f04b..a3c9de5 100644
--- a/examples/org.eclipse.graphiti.examples.composite/plugin.properties
+++ b/examples/org.eclipse.graphiti.examples.composite/plugin.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2013, 2019 SRC
 #
-# Copyright (c) 2013 SRC
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
 #    pjpaulin - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Composite Examples (Incubation)
 providerName = Eclipse Modeling Project 
 
diff --git a/examples/org.eclipse.graphiti.examples.composite/plugin.xml b/examples/org.eclipse.graphiti.examples.composite/plugin.xml
index 24db436..86a2fd3 100644
--- a/examples/org.eclipse.graphiti.examples.composite/plugin.xml
+++ b/examples/org.eclipse.graphiti.examples.composite/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2013 SRC.
-    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:
-       pjpaulin - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2013, 2019 SRC
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <plugin>
 
diff --git a/examples/org.eclipse.graphiti.examples.composite/pom.xml b/examples/org.eclipse.graphiti.examples.composite/pom.xml
index 0e5a489..3a24ecb 100644
--- a/examples/org.eclipse.graphiti.examples.composite/pom.xml
+++ b/examples/org.eclipse.graphiti.examples.composite/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/Activator.java b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/Activator.java
index 8a65b4c..efb1fb9 100644
--- a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/Activator.java
+++ b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/Activator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013 SRC
- * 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:
- *    pjpaulin - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SRC
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    pjpaulin - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.composite;
 
 import org.eclipse.ui.plugin.AbstractUIPlugin;
@@ -39,9 +36,8 @@
 	/*
 	 * (non-Javadoc)
 	 * 
-	 * @see
-	 * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext
-	 * )
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.
+	 * BundleContext )
 	 */
 	public void start(BundleContext context) throws Exception {
 		super.start(context);
@@ -51,9 +47,8 @@
 	/*
 	 * (non-Javadoc)
 	 * 
-	 * @see
-	 * org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext
-	 * )
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.
+	 * BundleContext )
 	 */
 	public void stop(BundleContext context) throws Exception {
 		plugin = null;
diff --git a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/DoubleDiagramDialog.java b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/DoubleDiagramDialog.java
index 27dcdfd..358ed04 100644
--- a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/DoubleDiagramDialog.java
+++ b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/DoubleDiagramDialog.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 Felix Velasco.
- * 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:
- *    fvelasco - Initial version
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+ * Copyright (c) 2013, 2019 Felix Velasco.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    fvelasco - Initial version
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.composite.dialog;
 
 import org.eclipse.core.resources.IResource;
diff --git a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/PreviewDiagramHandler.java b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/PreviewDiagramHandler.java
index 2771fc9..4640fa3 100644
--- a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/PreviewDiagramHandler.java
+++ b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/dialog/PreviewDiagramHandler.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 Felix Velasco.
- * 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:
- *    fvelasco - Initial version
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 Felix Velasco.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    fvelasco - Initial version
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.composite.dialog;
 
 import org.eclipse.core.commands.AbstractHandler;
@@ -42,8 +39,8 @@
 
 		if (res1 != null && res2 != null) {
 
-			DoubleDiagramDialog dialog = new DoubleDiagramDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow()
-					.getShell(), res1, res2);
+			DoubleDiagramDialog dialog = new DoubleDiagramDialog(
+					PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), res1, res2);
 			dialog.open();
 		}
 		return null;
diff --git a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/view/DiagramCompositeViewExample.java b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/view/DiagramCompositeViewExample.java
index e99214a..933750a 100644
--- a/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/view/DiagramCompositeViewExample.java
+++ b/examples/org.eclipse.graphiti.examples.composite/src/org/eclipse/graphiti/examples/composite/view/DiagramCompositeViewExample.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013 SRC
- * 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:
- *    pjpaulin - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SRC
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    pjpaulin - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.composite.view;
 
 import org.eclipse.emf.common.util.URI;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/about.html b/examples/org.eclipse.graphiti.examples.filesystem.mm/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/about.html
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.examples.filesystem.mm/build.properties b/examples/org.eclipse.graphiti.examples.filesystem.mm/build.properties
index 385d38d..1b35bf9 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/build.properties
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = .,\
                model/,\
                META-INF/,\
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/model/filesystem.genmodel b/examples/org.eclipse.graphiti.examples.filesystem.mm/model/filesystem.genmodel
index 7715b8d..606d8c9 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/model/filesystem.genmodel
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/model/filesystem.genmodel
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="&lt;copyright>&#xD;&#xA;&#xD;&#xA;Copyright (c) 2012, 2012 SAP AG.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-v10.html&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;   SAP AG - initial API, implementation and documentation&#xD;&#xA;&#xD;&#xA;&lt;/copyright>"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="&lt;copyright>&#xD;&#xA;&#xD;&#xA;Copyright (c) 2012, 2012 SAP AG.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v2.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-2.0&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;   SAP AG - initial API, implementation and documentation&#xD;&#xA;&#xD;&#xA;&lt;/copyright>"
     modelDirectory="/org.eclipse.graphiti.examples.filesystem.mm/src" editDirectory="/org.eclipse.graphiti.examples.filesystem.edit/src"
     editorDirectory="/org.eclipse.graphiti.examples.filesystem.editor/src" modelPluginID="org.eclipse.graphiti.examples.filesystem.mm"
     modelName="Filesystem" testSuiteClass="org.eclipse.graphiti.examples.filesystem.tests.FilesystemAllTests"
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.properties b/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.properties
index c561acb..6cd418a 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.properties
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Filesystem Example Model (Incubation)
 providerName = Eclipse Modeling Project
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.xml b/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.xml
index c6c288f..63bcc98 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.xml
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2012, 2012 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/pom.xml b/examples/org.eclipse.graphiti.examples.filesystem.mm/pom.xml
index e5d63de..66feff3 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/pom.xml
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/File.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/File.java
index b23bb10..0a661b0 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/File.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/File.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Filesystem.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Filesystem.java
index ee9fe0d..7a85052 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Filesystem.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Filesystem.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
 
 /**
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemFactory.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemFactory.java
index 6cfcfaf..b9f3ea8 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemFactory.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemFactory.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem;
 
 import org.eclipse.emf.ecore.EFactory;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemPackage.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemPackage.java
index 1f92257..c7e05ef 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemPackage.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/FilesystemPackage.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Folder.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Folder.java
index 779985e..2d129ff 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Folder.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/Folder.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
 
 /**
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FileImpl.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FileImpl.java
index 01a92fd..5cbfa3f 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FileImpl.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FileImpl.java
@@ -1,26 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.examples.mm.filesystem.File;
 import org.eclipse.graphiti.examples.mm.filesystem.FilesystemPackage;
 
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemFactoryImpl.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemFactoryImpl.java
index 4fdaa45..7679339 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemFactoryImpl.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemFactoryImpl.java
@@ -1,28 +1,27 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.impl;
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
-
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-
-import org.eclipse.graphiti.examples.mm.filesystem.*;
+import org.eclipse.graphiti.examples.mm.filesystem.File;
+import org.eclipse.graphiti.examples.mm.filesystem.Filesystem;
+import org.eclipse.graphiti.examples.mm.filesystem.FilesystemFactory;
+import org.eclipse.graphiti.examples.mm.filesystem.FilesystemPackage;
+import org.eclipse.graphiti.examples.mm.filesystem.Folder;
 
 /**
  * <!-- begin-user-doc -->
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemImpl.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemImpl.java
index bdc5852..430b515 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemImpl.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemImpl.java
@@ -1,35 +1,28 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.examples.mm.filesystem.File;
 import org.eclipse.graphiti.examples.mm.filesystem.Filesystem;
 import org.eclipse.graphiti.examples.mm.filesystem.FilesystemPackage;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemPackageImpl.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemPackageImpl.java
index 875385e..98b443a 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemPackageImpl.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FilesystemPackageImpl.java
@@ -1,26 +1,22 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.impl;
 
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
-
 import org.eclipse.emf.ecore.impl.EPackageImpl;
-
 import org.eclipse.graphiti.examples.mm.filesystem.File;
 import org.eclipse.graphiti.examples.mm.filesystem.Filesystem;
 import org.eclipse.graphiti.examples.mm.filesystem.FilesystemFactory;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FolderImpl.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FolderImpl.java
index 0365248..9572e4a 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FolderImpl.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/impl/FolderImpl.java
@@ -1,32 +1,25 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EObjectResolvingEList;
-
 import org.eclipse.graphiti.examples.mm.filesystem.File;
 import org.eclipse.graphiti.examples.mm.filesystem.FilesystemPackage;
 import org.eclipse.graphiti.examples.mm.filesystem.Folder;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemAdapterFactory.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemAdapterFactory.java
index ffd131f..c5bc911 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemAdapterFactory.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemAdapterFactory.java
@@ -1,27 +1,25 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.util;
 
 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.Notifier;
-
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-
 import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.graphiti.examples.mm.filesystem.*;
+import org.eclipse.graphiti.examples.mm.filesystem.File;
+import org.eclipse.graphiti.examples.mm.filesystem.Filesystem;
+import org.eclipse.graphiti.examples.mm.filesystem.FilesystemPackage;
+import org.eclipse.graphiti.examples.mm.filesystem.Folder;
 
 /**
  * <!-- begin-user-doc -->
diff --git a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemSwitch.java b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemSwitch.java
index 95d2ea4..624cf84 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemSwitch.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem.mm/src/org/eclipse/graphiti/examples/mm/filesystem/util/FilesystemSwitch.java
@@ -1,25 +1,24 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.mm.filesystem.util;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
-
 import org.eclipse.emf.ecore.util.Switch;
-
-import org.eclipse.graphiti.examples.mm.filesystem.*;
+import org.eclipse.graphiti.examples.mm.filesystem.File;
+import org.eclipse.graphiti.examples.mm.filesystem.Filesystem;
+import org.eclipse.graphiti.examples.mm.filesystem.FilesystemPackage;
+import org.eclipse.graphiti.examples.mm.filesystem.Folder;
 
 /**
  * <!-- begin-user-doc -->
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/about.html b/examples/org.eclipse.graphiti.examples.filesystem/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/about.html
+++ b/examples/org.eclipse.graphiti.examples.filesystem/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.examples.filesystem/build.properties b/examples/org.eclipse.graphiti.examples.filesystem/build.properties
index b6a0e83..1382265 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/build.properties
+++ b/examples/org.eclipse.graphiti.examples.filesystem/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = plugin.xml,\
                META-INF/,\
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/plugin.properties b/examples/org.eclipse.graphiti.examples.filesystem/plugin.properties
index 4cbd318..30a410a 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/plugin.properties
+++ b/examples/org.eclipse.graphiti.examples.filesystem/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Filesystem Example Editor (Incubation)
 providerName = Eclipse Modeling Project
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/plugin.xml b/examples/org.eclipse.graphiti.examples.filesystem/plugin.xml
index 52dd5ab..c5896df 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/plugin.xml
+++ b/examples/org.eclipse.graphiti.examples.filesystem/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2012, 2012 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <plugin>
    <extension
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/pom.xml b/examples/org.eclipse.graphiti.examples.filesystem/pom.xml
index 4e607b2..6e69d5b 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/pom.xml
+++ b/examples/org.eclipse.graphiti.examples.filesystem/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/Activator.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/Activator.java
index 04c8215..e6abbcb 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/Activator.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/Activator.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem;
 
 import org.eclipse.jface.resource.ImageDescriptor;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/FilesystemImageProvider.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/FilesystemImageProvider.java
index 4a4fe82..28fdfc8 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/FilesystemImageProvider.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/FilesystemImageProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem;
 
 import org.eclipse.graphiti.ui.platform.AbstractImageProvider;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemDiagramTypeProvider.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemDiagramTypeProvider.java
index a1310e3..4fd8df9 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemDiagramTypeProvider.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemDiagramTypeProvider.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.diagram;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemFeatureProvider.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemFeatureProvider.java
index 390a959..2538522 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemFeatureProvider.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemFeatureProvider.java
@@ -1,18 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.diagram;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemToolBehaviorProvider.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemToolBehaviorProvider.java
index af2bd57..99e485b 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemToolBehaviorProvider.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/diagram/FilesystemToolBehaviorProvider.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.diagram;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/AddContainmentConnectionFeature.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/AddContainmentConnectionFeature.java
index fe80583..4a05e22 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/AddContainmentConnectionFeature.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/AddContainmentConnectionFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.features;
 
 import org.eclipse.graphiti.features.IAddFeature;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateContainmentConnectionFeature.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateContainmentConnectionFeature.java
index 289cba2..272de1d 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateContainmentConnectionFeature.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateContainmentConnectionFeature.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.features;
 
 import org.eclipse.emf.ecore.EObject;
@@ -28,8 +26,8 @@
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.mm.pictograms.Shape;
 
-public class CreateContainmentConnectionFeature extends AbstractCreateConnectionFeature implements
-		ICreateConnectionFeature {
+public class CreateContainmentConnectionFeature extends AbstractCreateConnectionFeature
+		implements ICreateConnectionFeature {
 
 	public CreateContainmentConnectionFeature(IFeatureProvider fp) {
 		super(fp, "Containment", "Creates a new containment relation between two folders");
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateInnerFileFeature.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateInnerFileFeature.java
index e884d07..6b45d0b 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateInnerFileFeature.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/CreateInnerFileFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.features;
 
 import org.eclipse.graphiti.examples.mm.filesystem.File;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/DeleteInnerFileFeature.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/DeleteInnerFileFeature.java
index 9744aac..7605c34 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/DeleteInnerFileFeature.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/DeleteInnerFileFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.features;
 
 import org.eclipse.emf.ecore.util.EcoreUtil;
@@ -52,8 +64,8 @@
 				if (domainObject instanceof File) {
 					if (pictogramElement instanceof Shape && pictogramElement.eContainer() instanceof ContainerShape
 							&& pictogramElement.eContainer().eContainer() instanceof ContainerShape) {
-						if (getBusinessObjectForPictogramElement((ContainerShape) pictogramElement.eContainer()
-								.eContainer()) instanceof Folder) {
+						if (getBusinessObjectForPictogramElement(
+								(ContainerShape) pictogramElement.eContainer().eContainer()) instanceof Folder) {
 							return (File) domainObject;
 						}
 					}
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/GradientColorFeature.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/GradientColorFeature.java
index aa0ffe6..56120f5 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/GradientColorFeature.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/features/GradientColorFeature.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 8/31/2012
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.features;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilePattern.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilePattern.java
index 87efb11..15a1b8f 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilePattern.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilePattern.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.patterns;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilesystemPattern.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilesystemPattern.java
index 5d1be1f..3075965 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilesystemPattern.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FilesystemPattern.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.patterns;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FolderPattern.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FolderPattern.java
index ac4e6db..810f2b8 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FolderPattern.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/patterns/FolderPattern.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.patterns;
 
 import java.util.List;
@@ -146,8 +158,8 @@
 		} else if (id.equals(ID_NAME_SEPARATOR)) {
 			Polyline polyline = (Polyline) ga;
 			polyline.getPoints().clear();
-			List<Point> pointList = Graphiti.getGaService().createPointList(
-					new int[] { 0, 30, outerRectangle.getWidth(), 30 });
+			List<Point> pointList = Graphiti.getGaService()
+					.createPointList(new int[] { 0, 30, outerRectangle.getWidth(), 30 });
 			polyline.getPoints().addAll(pointList);
 			changesDone = true;
 		} else if (id.equals(ID_FILE_NAMES_RECTANGLE)) {
diff --git a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/ui/FilesystemPredefinedColoredAreas.java b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/ui/FilesystemPredefinedColoredAreas.java
index 0e5869d..45d235b 100644
--- a/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/ui/FilesystemPredefinedColoredAreas.java
+++ b/examples/org.eclipse.graphiti.examples.filesystem/src/org/eclipse/graphiti/examples/filesystem/ui/FilesystemPredefinedColoredAreas.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.filesystem.ui;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/about.html b/examples/org.eclipse.graphiti.examples.tutorial/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/about.html
+++ b/examples/org.eclipse.graphiti.examples.tutorial/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.examples.tutorial/build.properties b/examples/org.eclipse.graphiti.examples.tutorial/build.properties
index 92893d1..af4bd9f 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/build.properties
+++ b/examples/org.eclipse.graphiti.examples.tutorial/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/plugin.properties b/examples/org.eclipse.graphiti.examples.tutorial/plugin.properties
index b20c151..4eee0c5 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/plugin.properties
+++ b/examples/org.eclipse.graphiti.examples.tutorial/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Examples Tutorial (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/plugin.xml b/examples/org.eclipse.graphiti.examples.tutorial/plugin.xml
index 5690ab7..8b93289 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/plugin.xml
+++ b/examples/org.eclipse.graphiti.examples.tutorial/plugin.xml
@@ -1,20 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2010 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Bug 341898 - Support for AdvancedPropertySheet
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/pom.xml b/examples/org.eclipse.graphiti.examples.tutorial/pom.xml
index e5121e5..2ad9284 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/pom.xml
+++ b/examples/org.eclipse.graphiti.examples.tutorial/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/ITutorialRenderingStyle.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/ITutorialRenderingStyle.java
index 7377223..f3345f8 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/ITutorialRenderingStyle.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/ITutorialRenderingStyle.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import org.eclipse.graphiti.util.IPredefinedRenderingStyle;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/Messages.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/Messages.java
index 0642d42..48608e4 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/Messages.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/Messages.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import org.eclipse.osgi.util.NLS;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/PropertyUtil.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/PropertyUtil.java
index baa7a51..15d880e 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/PropertyUtil.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/PropertyUtil.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/StyleUtil.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/StyleUtil.java
index d1f1f96..67ce713 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/StyleUtil.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/StyleUtil.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import org.eclipse.graphiti.mm.algorithms.styles.LineStyle;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialColoredAreas.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialColoredAreas.java
index ee5c449..82a967d 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialColoredAreas.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialColoredAreas.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialImageProvider.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialImageProvider.java
index 31db28a..2c8c853 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialImageProvider.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialImageProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import org.eclipse.graphiti.ui.platform.AbstractImageProvider;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialUtil.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialUtil.java
index ef16c4b..0ec224f 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialUtil.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/TutorialUtil.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial;
 
 import java.io.IOException;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialDiagramTypeProvider.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialDiagramTypeProvider.java
index 9a62c6d..906f83e 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialDiagramTypeProvider.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialDiagramTypeProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.diagram;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialFeatureProvider.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialFeatureProvider.java
index 5f577a9..828f3cc 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialFeatureProvider.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialFeatureProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 434658 - execute a feature in an asynchronous job
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 434658 - execute a feature in an asynchronous job
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.diagram;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialToolBehaviorProvider.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialToolBehaviorProvider.java
index 447a421..a0e7bd9 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialToolBehaviorProvider.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/diagram/TutorialToolBehaviorProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2017 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.diagram;
 
 import java.util.ArrayList;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEClassFeature.java
index 6ea929b..49e51b9 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEReferenceFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEReferenceFeature.java
index fe54e1c..08d300c 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEReferenceFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAddEReferenceFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EReference;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAssociateDiagramEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAssociateDiagramEClassFeature.java
index 3776c75..f769279 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAssociateDiagramEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialAssociateDiagramEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialChangeColorEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialChangeColorEClassFeature.java
index cd8eca5..49db97b 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialChangeColorEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialChangeColorEClassFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCollapseDummyFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCollapseDummyFeature.java
index 4f43f83..16228be 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCollapseDummyFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCollapseDummyFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCopyEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCopyEClassFeature.java
index 22a2367..e9ceb7f 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCopyEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCopyEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEClassFeature.java
index 31db083..6431ab6 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEReferenceFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEReferenceFeature.java
index 4ae391f..d7f1dd2 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEReferenceFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialCreateEReferenceFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDirectEditEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDirectEditEClassFeature.java
index 59afd4e..d1ef79e 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDirectEditEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDirectEditEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDrillDownEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDrillDownEClassFeature.java
index e81c77a..eefa48d 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDrillDownEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialDrillDownEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import java.util.Collection;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLayoutEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLayoutEClassFeature.java
index e61d247..d00f0e9 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLayoutEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLayoutEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLongRunningCustomFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLongRunningCustomFeature.java
index bc3f7d4..383ce8b 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLongRunningCustomFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialLongRunningCustomFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 434658 - execute a feature in an asynchronous job
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 434658 - execute a feature in an asynchronous job
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.core.runtime.IProgressMonitor;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialMoveEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialMoveEClassFeature.java
index 5747dec..cceacdd 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialMoveEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialMoveEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialPasteEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialPasteEClassFeature.java
index 69909d5..ce28fcf 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialPasteEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialPasteEClassFeature.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 339525 - Enrich paste context with location information
- *    mwenz - Bug 375533 - Problems with copy&paste in the tutorial
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 339525 - Enrich paste context with location information
+*    mwenz - Bug 375533 - Problems with copy&paste in the tutorial
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialReconnectionFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialReconnectionFeature.java
index f4e7f65..07775da 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialReconnectionFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialReconnectionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialRenameEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialRenameEClassFeature.java
index fdade6a..38f0eee 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialRenameEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialRenameEClassFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialResizeEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialResizeEClassFeature.java
index 0149663..e69197f 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialResizeEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialResizeEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialUpdateEClassFeature.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialUpdateEClassFeature.java
index 0422b2a..a9e04ce 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialUpdateEClassFeature.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/features/TutorialUpdateEClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.features;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/AddAllClassesCommand.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/AddAllClassesCommand.java
index 2cb0c07..1d9bff5 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/AddAllClassesCommand.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/AddAllClassesCommand.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.handlers;
 
 import org.eclipse.core.resources.IFile;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/CreateDiagramWithAllClassesHandler.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/CreateDiagramWithAllClassesHandler.java
index 2c6edb4..ba520bc 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/CreateDiagramWithAllClassesHandler.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/handlers/CreateDiagramWithAllClassesHandler.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.handlers;
 
 import java.io.IOException;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/messages.properties b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/messages.properties
index be0a819..3cd20a0 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/messages.properties
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/messages.properties
@@ -1,3 +1,16 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
+
 CreateDiagramWithAllClassesHandler_ErrorTitle=Error Occurred
 CreateDiagramWithAllClassesHandler_NewDiagramDescription=Enter the name for the new diagram
 CreateDiagramWithAllClassesHandler_NewDiagramTitle=New Diagram
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/EReferencePropertySource.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/EReferencePropertySource.java
index 75e1841..e98ab16 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/EReferencePropertySource.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/EReferencePropertySource.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.property;
 
 import org.eclipse.emf.ecore.EReference;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/GraphitiEditPartToIPropertySourceAdapterFactory.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/GraphitiEditPartToIPropertySourceAdapterFactory.java
index 2147667..956c85c 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/GraphitiEditPartToIPropertySourceAdapterFactory.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/GraphitiEditPartToIPropertySourceAdapterFactory.java
@@ -1,23 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.property;
 
 import org.eclipse.core.runtime.IAdapterFactory;
 import org.eclipse.emf.ecore.EReference;
+import org.eclipse.gef.EditPart;
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.ui.editor.IDiagramContainerUI;
 import org.eclipse.graphiti.ui.platform.GraphitiConnectionEditPart;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassFilter.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassFilter.java
index 5c604cc..3ae5742 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassFilter.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassFilter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.property;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassSection.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassSection.java
index 31d9c08..597ea8a 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassSection.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEClassSection.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.property;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEReferenceFilter.java b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEReferenceFilter.java
index b99c6e5..2ba00ad 100644
--- a/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEReferenceFilter.java
+++ b/examples/org.eclipse.graphiti.examples.tutorial/src/org/eclipse/graphiti/examples/tutorial/property/TutorialEReferenceFilter.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.examples.tutorial.property;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/examples/org.eclipse.graphiti.ui.capabilities/about.html b/examples/org.eclipse.graphiti.ui.capabilities/about.html
index c258ef5..38cecbb 100644
--- a/examples/org.eclipse.graphiti.ui.capabilities/about.html
+++ b/examples/org.eclipse.graphiti.ui.capabilities/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/examples/org.eclipse.graphiti.ui.capabilities/build.properties b/examples/org.eclipse.graphiti.ui.capabilities/build.properties
index 65eb921..48221f0 100644
--- a/examples/org.eclipse.graphiti.ui.capabilities/build.properties
+++ b/examples/org.eclipse.graphiti.ui.capabilities/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################source.. = src/
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = META-INF/,\
                .,\
                plugin.xml,\
diff --git a/examples/org.eclipse.graphiti.ui.capabilities/plugin.properties b/examples/org.eclipse.graphiti.ui.capabilities/plugin.properties
index f763ba3..5de57f7 100644
--- a/examples/org.eclipse.graphiti.ui.capabilities/plugin.properties
+++ b/examples/org.eclipse.graphiti.ui.capabilities/plugin.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Examples for Capabilities (Incubation)
 providerName = Eclipse Modeling Project 
 
diff --git a/examples/org.eclipse.graphiti.ui.capabilities/plugin.xml b/examples/org.eclipse.graphiti.ui.capabilities/plugin.xml
index 7266dd3..25c79eb 100644
--- a/examples/org.eclipse.graphiti.ui.capabilities/plugin.xml
+++ b/examples/org.eclipse.graphiti.ui.capabilities/plugin.xml
@@ -1,20 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2011 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
- --><plugin>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
+-->
+<plugin>
    <extension
          point="org.eclipse.ui.activities">
          
diff --git a/examples/org.eclipse.graphiti.ui.capabilities/pom.xml b/examples/org.eclipse.graphiti.ui.capabilities/pom.xml
index b6453f6..f4d5894 100644
--- a/examples/org.eclipse.graphiti.ui.capabilities/pom.xml
+++ b/examples/org.eclipse.graphiti.ui.capabilities/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.export.feature/build.properties b/features/org.eclipse.graphiti.export.feature/build.properties
index cf8c483..63ae4fb 100644
--- a/features/org.eclipse.graphiti.export.feature/build.properties
+++ b/features/org.eclipse.graphiti.export.feature/build.properties
@@ -1,22 +1,18 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = feature.xml,\
                feature.properties,\
-               license.html,\
-               epl-v10.html
+               license.html
 src.includes = feature.xml,\
                feature.properties,\
                license.html,\
diff --git a/features/org.eclipse.graphiti.export.feature/epl-v10.html b/features/org.eclipse.graphiti.export.feature/epl-v10.html
deleted file mode 100644
index fd39122..0000000
--- a/features/org.eclipse.graphiti.export.feature/epl-v10.html
+++ /dev/null
@@ -1,261 +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 (&quot;AGREEMENT&quot;). ANY USE, REPRODUCTION OR
-DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
-AGREEMENT.</p>
-
-<p><b>1. DEFINITIONS</b></p>
-
-<p>&quot;Contribution&quot; 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>&quot;Contributor&quot; means any person or entity that distributes
-the Program.</p>
-
-<p>&quot;Licensed Patents&quot; 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>&quot;Program&quot; means the Contributions distributed in accordance
-with this Agreement.</p>
-
-<p>&quot;Recipient&quot; 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
-(&quot;Commercial Contributor&quot;) hereby agrees to defend and
-indemnify every other Contributor (&quot;Indemnified Contributor&quot;)
-against any losses, damages and costs (collectively &quot;Losses&quot;)
-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 &quot;AS IS&quot; 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>
diff --git a/features/org.eclipse.graphiti.export.feature/feature.properties b/features/org.eclipse.graphiti.export.feature/feature.properties
index 1b85b15..ff2c967 100644
--- a/features/org.eclipse.graphiti.export.feature/feature.properties
+++ b/features/org.eclipse.graphiti.export.feature/feature.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 featureName = Graphiti Export (Incubation)
 providerName = Eclipse Modeling Project
 description = This is the exporters feature of the Graphiti framework. This feature enhances the Graphiti runtime feature (org.eclipse.graphiti.feature) with additional export possibilities (currently an SVG exporter for diagrams is the only contained extension).
diff --git a/features/org.eclipse.graphiti.export.feature/feature.xml b/features/org.eclipse.graphiti.export.feature/feature.xml
index 3e1bd0a..48c01b2 100644
--- a/features/org.eclipse.graphiti.export.feature/feature.xml
+++ b/features/org.eclipse.graphiti.export.feature/feature.xml
@@ -1,16 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2012, 2015 SAP AG.
-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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Bug 467824 - Graphiti needs to use org.apache.batik.dom version 1.7.1 instead of 1.7.0
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <feature
       id="org.eclipse.graphiti.export.feature"
diff --git a/features/org.eclipse.graphiti.export.feature/license.html b/features/org.eclipse.graphiti.export.feature/license.html
index f19c483..0f65641 100644
--- a/features/org.eclipse.graphiti.export.feature/license.html
+++ b/features/org.eclipse.graphiti.export.feature/license.html
@@ -1,108 +1,263 @@
-<?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" />
-<title>Eclipse Foundation Software User Agreement</title>
-</head>
-
-<body lang="EN-US">
-<h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
-
-<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>
-
-<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>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>
-
-<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>
-
-<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>
-
-<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>
-
-<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>
-
-<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>
-
-<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>
-
-<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>
+﻿<!DOCTYPE HTML>
+<!-- saved from url=(0058)https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html -->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><HTML 
+lang="en" lang="en" xml:lang="en" 
+xmlns="http://www.w3.org/1999/xhtml"><HEAD><META content="IE=11.0000" 
+http-equiv="X-UA-Compatible">
+     
+<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>
+   
+<META name="GENERATOR" content="MSHTML 11.00.10570.1001"></HEAD>   
+<BODY>
+<H1>Eclipse Public License - v 2.0</H1>
+<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>
+<H2 id="definitions">1. DEFINITIONS</H2>
+<P>“Contribution” 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         “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 
+  changes or additions to the Program that        are not Modified Works.       
+  </LI></UL>
+<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      
+or any Secondary License (as applicable), including Contributors.     </P>
+<P>“Derivative Works” 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>“Modified Works” 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>“Distribute” means the acts of a) distributing or b) making available      in 
+any manner that enables the transfer of a copy.     </P>
+<P>“Source Code” 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>“Secondary License” 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'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'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' 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      
+(‘notices’) 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 (“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>
+<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 “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>
+<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'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.     </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 – Form of Secondary Licenses Notice</H2>
+<P>“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}.”     </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>
diff --git a/features/org.eclipse.graphiti.export.feature/pom.xml b/features/org.eclipse.graphiti.export.feature/pom.xml
index 7a04743..033740f 100644
--- a/features/org.eclipse.graphiti.export.feature/pom.xml
+++ b/features/org.eclipse.graphiti.export.feature/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.feature.examples/build.properties b/features/org.eclipse.graphiti.feature.examples/build.properties
index 2da8064..91d1b70 100644
--- a/features/org.eclipse.graphiti.feature.examples/build.properties
+++ b/features/org.eclipse.graphiti.feature.examples/build.properties
@@ -1,20 +1,17 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = feature.xml,\
                feature.properties
 src.includes = feature.xml,\
diff --git a/features/org.eclipse.graphiti.feature.examples/feature.properties b/features/org.eclipse.graphiti.feature.examples/feature.properties
index e61aab4..1cf3374 100644
--- a/features/org.eclipse.graphiti.feature.examples/feature.properties
+++ b/features/org.eclipse.graphiti.feature.examples/feature.properties
@@ -1,20 +1,17 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 featureName = Graphiti Examples (Incubation)
 providerName = Eclipse Modeling Project
 description = This feature contains the tutorial, the documentation and examples for the Graphiti framework. Graphiti supports the fast and easy creation of unified graphical tools, which can graphically display and edit underlying domain models using a tool-defined notation.
diff --git a/features/org.eclipse.graphiti.feature.examples/feature.xml b/features/org.eclipse.graphiti.feature.examples/feature.xml
index 995e741..e8dd1d9 100644
--- a/features/org.eclipse.graphiti.feature.examples/feature.xml
+++ b/features/org.eclipse.graphiti.feature.examples/feature.xml
@@ -1,19 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2005, 2013 SAP AG.
-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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Update of Eclipse license
-       mwenz - Added capabilities plugin
-       mwenz - Use central Eclipse license feature
-       mwenz - Added composite example
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Update of Eclipse license
+*    mwenz - Added capabilities plugin
+*    mwenz - Use central Eclipse license feature
+*    mwenz - Added composite example
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <feature
       id="org.eclipse.graphiti.feature.examples"
diff --git a/features/org.eclipse.graphiti.feature.examples/pom.xml b/features/org.eclipse.graphiti.feature.examples/pom.xml
index 241a306..ce108cd 100644
--- a/features/org.eclipse.graphiti.feature.examples/pom.xml
+++ b/features/org.eclipse.graphiti.feature.examples/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.feature.tools/build.properties b/features/org.eclipse.graphiti.feature.tools/build.properties
index d5a0a0c..7ff17d2 100644
--- a/features/org.eclipse.graphiti.feature.tools/build.properties
+++ b/features/org.eclipse.graphiti.feature.tools/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = feature.xml,\
                feature.properties
 src.includes = feature.xml,\
diff --git a/features/org.eclipse.graphiti.feature.tools/feature.properties b/features/org.eclipse.graphiti.feature.tools/feature.properties
index 611c6a7..7082c86 100644
--- a/features/org.eclipse.graphiti.feature.tools/feature.properties
+++ b/features/org.eclipse.graphiti.feature.tools/feature.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 featureName = Graphiti Tools (Incubation)
 providerName = Eclipse Modeling Project
 description = This feature contains the tools for for developing against the Graphiti framework. Graphiti supports the fast and easy creation of unified graphical tools, which can graphically display and edit underlying domain models using a tool-defined notation.
diff --git a/features/org.eclipse.graphiti.feature.tools/feature.xml b/features/org.eclipse.graphiti.feature.tools/feature.xml
index 9df9951..d392ca1 100644
--- a/features/org.eclipse.graphiti.feature.tools/feature.xml
+++ b/features/org.eclipse.graphiti.feature.tools/feature.xml
@@ -1,15 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2012, 2012 SAP AG.
-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:
-       SAP AG - initial API, implementation and documentation
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <feature
       id="org.eclipse.graphiti.feature.tools"
diff --git a/features/org.eclipse.graphiti.feature.tools/pom.xml b/features/org.eclipse.graphiti.feature.tools/pom.xml
index 6c012f7..bfbcbb3 100644
--- a/features/org.eclipse.graphiti.feature.tools/pom.xml
+++ b/features/org.eclipse.graphiti.feature.tools/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.feature/build.properties b/features/org.eclipse.graphiti.feature/build.properties
index 390ba4c..320b8d8 100644
--- a/features/org.eclipse.graphiti.feature/build.properties
+++ b/features/org.eclipse.graphiti.feature/build.properties
@@ -1,20 +1,18 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 201! SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
+
 bin.includes = feature.xml,\
                feature.properties
 src.includes = feature.xml,\
diff --git a/features/org.eclipse.graphiti.feature/feature.properties b/features/org.eclipse.graphiti.feature/feature.properties
index 4e5117d..b7a1228 100644
--- a/features/org.eclipse.graphiti.feature/feature.properties
+++ b/features/org.eclipse.graphiti.feature/feature.properties
@@ -1,20 +1,18 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
+
 featureName = Graphiti (Incubation)
 providerName = Eclipse Modeling Project
 description = This is the runtime feature of the Graphiti framework. Graphiti supports the fast and easy creation of unified graphical tools, which can graphically display and edit underlying domain models using a tool-defined notation. Only this Graphiti feature is needed for creating Eclipse-based applications containing tools using Graphiti.
diff --git a/features/org.eclipse.graphiti.feature/feature.xml b/features/org.eclipse.graphiti.feature/feature.xml
index 34f577f..a113d36 100644
--- a/features/org.eclipse.graphiti.feature/feature.xml
+++ b/features/org.eclipse.graphiti.feature/feature.xml
@@ -1,17 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2005, 2011 SAP AG.
-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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Update of Eclipse license
-       mwenz - Use central Eclipse license feature
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Update of Eclipse license
+*    mwenz - Use central Eclipse license feature
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <feature
       id="org.eclipse.graphiti.feature"
diff --git a/features/org.eclipse.graphiti.feature/pom.xml b/features/org.eclipse.graphiti.feature/pom.xml
index dd58b10..68df33a 100644
--- a/features/org.eclipse.graphiti.feature/pom.xml
+++ b/features/org.eclipse.graphiti.feature/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.sdk.feature/build.properties b/features/org.eclipse.graphiti.sdk.feature/build.properties
index 2da8064..91d1b70 100644
--- a/features/org.eclipse.graphiti.sdk.feature/build.properties
+++ b/features/org.eclipse.graphiti.sdk.feature/build.properties
@@ -1,20 +1,17 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = feature.xml,\
                feature.properties
 src.includes = feature.xml,\
diff --git a/features/org.eclipse.graphiti.sdk.feature/feature.properties b/features/org.eclipse.graphiti.sdk.feature/feature.properties
index 3944675..d5ae455 100644
--- a/features/org.eclipse.graphiti.sdk.feature/feature.properties
+++ b/features/org.eclipse.graphiti.sdk.feature/feature.properties
@@ -1,20 +1,17 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 featureName = Graphiti SDK (Incubation)
 providerName = Eclipse Modeling Project
 description = This is the full blown SDK feature of the Graphiti framework containing the framework itself plus the source code, documentation and the tutorial with its source code. Install this feature if you would like to start using Graphiti. Graphiti supports the fast and easy creation of unified graphical tools, which can graphically display and edit underlying domain models using a tool-defined notation.
diff --git a/features/org.eclipse.graphiti.sdk.feature/feature.xml b/features/org.eclipse.graphiti.sdk.feature/feature.xml
index 81bb66f..c94f465 100644
--- a/features/org.eclipse.graphiti.sdk.feature/feature.xml
+++ b/features/org.eclipse.graphiti.sdk.feature/feature.xml
@@ -1,17 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2005, 2011 SAP AG.
-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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Update of Eclipse license
-       mwenz - Use central Eclipse license feature
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Update of Eclipse license
+*    mwenz - Use central Eclipse license feature
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <feature
       id="org.eclipse.graphiti.sdk.feature"
diff --git a/features/org.eclipse.graphiti.sdk.feature/pom.xml b/features/org.eclipse.graphiti.sdk.feature/pom.xml
index 6ff175b..71ddaf0 100644
--- a/features/org.eclipse.graphiti.sdk.feature/pom.xml
+++ b/features/org.eclipse.graphiti.sdk.feature/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.sdk.plus.feature/build.properties b/features/org.eclipse.graphiti.sdk.plus.feature/build.properties
index 2da8064..91d1b70 100644
--- a/features/org.eclipse.graphiti.sdk.plus.feature/build.properties
+++ b/features/org.eclipse.graphiti.sdk.plus.feature/build.properties
@@ -1,20 +1,17 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = feature.xml,\
                feature.properties
 src.includes = feature.xml,\
diff --git a/features/org.eclipse.graphiti.sdk.plus.feature/feature.properties b/features/org.eclipse.graphiti.sdk.plus.feature/feature.properties
index 52f91b0..a5ab662 100644
--- a/features/org.eclipse.graphiti.sdk.plus.feature/feature.properties
+++ b/features/org.eclipse.graphiti.sdk.plus.feature/feature.properties
@@ -1,20 +1,17 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 featureName = Graphiti SDK Plus (Incubation)
 providerName = Eclipse Modeling Project
 description = This is the SDK Plus feature of the Graphiti framework containing the SDK feature plus all available add-ons. Install this feature if you want to develop on top of Graphiti and if you need at least one of the add-ons. Graphiti supports the fast and easy creation of unified graphical tools, which can graphically display and edit underlying domain models using a tool-defined notation. 
diff --git a/features/org.eclipse.graphiti.sdk.plus.feature/feature.xml b/features/org.eclipse.graphiti.sdk.plus.feature/feature.xml
index 8bcf1f9..0ed8327 100644
--- a/features/org.eclipse.graphiti.sdk.plus.feature/feature.xml
+++ b/features/org.eclipse.graphiti.sdk.plus.feature/feature.xml
@@ -1,17 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2005, 2011 SAP AG.
-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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Update of Eclipse license
-       mwenz - Use central Eclipse license feature
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Update of Eclipse license
+*    mwenz - Use central Eclipse license feature
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <feature
       id="org.eclipse.graphiti.sdk.plus.feature"
diff --git a/features/org.eclipse.graphiti.sdk.plus.feature/pom.xml b/features/org.eclipse.graphiti.sdk.plus.feature/pom.xml
index 2b06910..5c13002 100644
--- a/features/org.eclipse.graphiti.sdk.plus.feature/pom.xml
+++ b/features/org.eclipse.graphiti.sdk.plus.feature/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/features/org.eclipse.graphiti.site/about.html b/features/org.eclipse.graphiti.site/about.html
index d35d5ae..38cecbb 100644
--- a/features/org.eclipse.graphiti.site/about.html
+++ b/features/org.eclipse.graphiti.site/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2007</p>	
+<p>June 5, 2006</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 
@@ -25,4 +25,4 @@
 and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
 
 </body>
-</html>
+</html>
\ No newline at end of file
diff --git a/features/org.eclipse.graphiti.site/build.properties b/features/org.eclipse.graphiti.site/build.properties
index 49d0f36..2893146 100644
--- a/features/org.eclipse.graphiti.site/build.properties
+++ b/features/org.eclipse.graphiti.site/build.properties
@@ -1,15 +1,17 @@
-# Copyright (c) 2005 - 2011 SAP AG.
-# 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
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API and implementation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
-
-# NLS_MESSAGEFORMAT_VAR
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 bin.includes = feature.xml,\
                copyright.txt,\
diff --git a/features/org.eclipse.graphiti.site/copyright.txt b/features/org.eclipse.graphiti.site/copyright.txt
index 11a372e..2ac8050 100644
--- a/features/org.eclipse.graphiti.site/copyright.txt
+++ b/features/org.eclipse.graphiti.site/copyright.txt
@@ -1,8 +1,8 @@
-Copyright (c) 2005 - 2011 SAP AG.
+Copyright (c) 2005 - 2019 SAP SE.
 All rights reserved. This program and the accompanying materials
-are made available under the terms of the Eclipse Public License v1.0
+are made available under the terms of the Eclipse Public License v2.0
 which accompanies this distribution, and is available at
-http://www.eclipse.org/legal/epl-v10.html
+http://www.eclipse.org/legal/epl-2.0
 
 Contributors:
-   SAP AG - initial API and implementation
\ No newline at end of file
+   SAP SE - initial API and implementation
\ No newline at end of file
diff --git a/features/org.eclipse.graphiti.site/feature.properties b/features/org.eclipse.graphiti.site/feature.properties
index acce205..76d7af0 100644
--- a/features/org.eclipse.graphiti.site/feature.properties
+++ b/features/org.eclipse.graphiti.site/feature.properties
@@ -1,15 +1,17 @@
-# Copyright (c) 2005 - 2011 SAP AG.
-# 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
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API and implementation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Update of Eclipse license
 #    mwenz - Use central Eclipse license feature
-
-# NLS_MESSAGEFORMAT_VAR
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 # ==============================================================================
 # Do not change the properties between this line and the last line containing:
diff --git a/features/org.eclipse.graphiti.site/feature.xml b/features/org.eclipse.graphiti.site/feature.xml
index 2907503..d00ccf2 100644
--- a/features/org.eclipse.graphiti.site/feature.xml
+++ b/features/org.eclipse.graphiti.site/feature.xml
@@ -1,18 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
-<copyright>
-Copyright (c) 2005 - 2011 SAP AG.
-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:
-	  SAP AG - initial API and implementation
-	  mwenz - Update of Eclipse license
-      mwenz - Use central Eclipse license feature
-
-</copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Update of Eclipse license
+*    mwenz - Use central Eclipse license feature
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
 -->
 <feature
       id="org.eclipse.graphiti.site"
diff --git a/features/org.eclipse.graphiti.site/pom.xml b/features/org.eclipse.graphiti.site/pom.xml
index c000c79..f1fd35f 100644
--- a/features/org.eclipse.graphiti.site/pom.xml
+++ b/features/org.eclipse.graphiti.site/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/parent/pom.xml b/parent/pom.xml
index c051797..52d946b 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti.export.batik/about.html b/plugins/org.eclipse.graphiti.export.batik/about.html
index c258ef5..38cecbb 100644
--- a/plugins/org.eclipse.graphiti.export.batik/about.html
+++ b/plugins/org.eclipse.graphiti.export.batik/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/plugins/org.eclipse.graphiti.export.batik/build.properties b/plugins/org.eclipse.graphiti.export.batik/build.properties
index f0285b9..a71ded7 100644
--- a/plugins/org.eclipse.graphiti.export.batik/build.properties
+++ b/plugins/org.eclipse.graphiti.export.batik/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 source.. = src/
 bin.includes = META-INF/,\
diff --git a/plugins/org.eclipse.graphiti.export.batik/plugin.properties b/plugins/org.eclipse.graphiti.export.batik/plugin.properties
index 8c56273..7b07697 100644
--- a/plugins/org.eclipse.graphiti.export.batik/plugin.properties
+++ b/plugins/org.eclipse.graphiti.export.batik/plugin.properties
@@ -1,17 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
+
 pluginName = Graphiti SVG Export (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/plugins/org.eclipse.graphiti.export.batik/plugin.xml b/plugins/org.eclipse.graphiti.export.batik/plugin.xml
index c0dc41c..b320d6a 100644
--- a/plugins/org.eclipse.graphiti.export.batik/plugin.xml
+++ b/plugins/org.eclipse.graphiti.export.batik/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2010 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <plugin>
    <extension
diff --git a/plugins/org.eclipse.graphiti.export.batik/pom.xml b/plugins/org.eclipse.graphiti.export.batik/pom.xml
index 1c77bc1..c8b5d6f 100644
--- a/plugins/org.eclipse.graphiti.export.batik/pom.xml
+++ b/plugins/org.eclipse.graphiti.export.batik/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GdiFont.java b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GdiFont.java
index 39b307d..87e60ac 100644
--- a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GdiFont.java
+++ b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GdiFont.java
@@ -1,15 +1,16 @@
-/******************************************************************************
- * Copyright (c) 2003, 2006 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    IBM Corporation - initial API and implementation
- *    SAP AG - copied the class from GMF runtime since Graphiti can not have a dependency to GMF 
- ****************************************************************************/
-
+/*********************************************************************
+* Copyright (c) 2003, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    IBM Corporation - initial API and implementation
+*    SAP AG - copied the class from GMF runtime since Graphiti can not have a dependency to GMF 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.export.batik;
 
 import java.awt.Font;
diff --git a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GraphicsToGraphics2DAdaptor.java b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GraphicsToGraphics2DAdaptor.java
index dc96d20..e536b3a 100644
--- a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GraphicsToGraphics2DAdaptor.java
+++ b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/GraphicsToGraphics2DAdaptor.java
@@ -1,20 +1,21 @@
-/******************************************************************************
- * Copyright (c) 2004, 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    IBM Corporation - initial API and implementation 
- *    SAP AG - copied class from GMF runtime since Graphiti can not have a dependency to GMF
- *    		   uses GraphitiUiInternal.getWorkbenchService() instead of 
- *    		   GMF's DisplayUtils, does not implement the interface
- *    		   DrawableRenderedImage, since it is not needed.
- *    mwenz - Bug  368146 - RuntimeException during SVG export
- *    Benjamin Schmeling - mwenz - Bug 369241 - SVG export does not rotate objects
- *    			
- ****************************************************************************/
+/*********************************************************************
+* Copyright (c) 2004, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    IBM Corporation - initial API and implementation 
+*    SAP AG - copied class from GMF runtime since Graphiti can not have a dependency to GMF
+*    		   uses GraphitiUiInternal.getWorkbenchService() instead of 
+*    		   GMF's DisplayUtils, does not implement the interface
+*    		   DrawableRenderedImage, since it is not needed.
+*    mwenz - Bug  368146 - RuntimeException during SVG export
+*    Benjamin Schmeling - mwenz - Bug 369241 - SVG export does not rotate objects
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.export.batik;
 
 import java.awt.AlphaComposite;
diff --git a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/ImageConverter.java b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/ImageConverter.java
index 45bf13f..55b9382 100644
--- a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/ImageConverter.java
+++ b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/ImageConverter.java
@@ -1,17 +1,18 @@
-/******************************************************************************
- * Copyright (c) 2004, 2010 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *    IBM Corporation - initial API and implementation 
- *    SAP AG - copied class from GMF runtime  since Graphiti can not have a dependency to GMF
- *    		   uses GraphitiUiInternal.getWorkbenchService() instead of 
- *    		   GMF's DisplayUtils			
- ****************************************************************************/
-
+/*********************************************************************
+* Copyright (c) 2004, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    IBM Corporation - initial API and implementation 
+*    SAP AG - copied class from GMF runtime  since Graphiti can not have a dependency to GMF
+*    		   uses GraphitiUiInternal.getWorkbenchService() instead of 
+*    		   GMF's DisplayUtils			
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.export.batik;
 
 import java.awt.image.BufferedImage;
diff --git a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/SVGExporter.java b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/SVGExporter.java
index 20d95ef..3c48cd3 100644
--- a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/SVGExporter.java
+++ b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/SVGExporter.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.export.batik;
 
 import java.io.FileOutputStream;
diff --git a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/Util.java b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/Util.java
index 3113362..309ab2a 100644
--- a/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/Util.java
+++ b/plugins/org.eclipse.graphiti.export.batik/src/org/eclipse/graphiti/export/batik/Util.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.export.batik;
 
 import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
diff --git a/plugins/org.eclipse.graphiti.mm/about.html b/plugins/org.eclipse.graphiti.mm/about.html
index c258ef5..38cecbb 100644
--- a/plugins/org.eclipse.graphiti.mm/about.html
+++ b/plugins/org.eclipse.graphiti.mm/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/plugins/org.eclipse.graphiti.mm/build.properties b/plugins/org.eclipse.graphiti.mm/build.properties
index b734552..0dcf83a 100644
--- a/plugins/org.eclipse.graphiti.mm/build.properties
+++ b/plugins/org.eclipse.graphiti.mm/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 bin.includes = .,\
                model/,\
diff --git a/plugins/org.eclipse.graphiti.mm/model/graphiti.genmodel b/plugins/org.eclipse.graphiti.mm/model/graphiti.genmodel
index 7ad7274..2dbb46e 100644
--- a/plugins/org.eclipse.graphiti.mm/model/graphiti.genmodel
+++ b/plugins/org.eclipse.graphiti.mm/model/graphiti.genmodel
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <genmodel:GenModel xmi:version="2.0"
     xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="&lt;copyright>&#xD;&#xA;&#xD;&#xA;Copyright (c) 2005, 2011 SAP AG.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-v10.html&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;   SAP AG - initial API, implementation and documentation&#xD;&#xA;&#xD;&#xA;&lt;/copyright>"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="&lt;copyright>&#xD;&#xA;&#xD;&#xA;Copyright (c) 2005, 2011 SAP AG.&#xD;&#xA;All rights reserved. This program and the accompanying materials&#xD;&#xA;are made available under the terms of the Eclipse Public License v2.0&#xD;&#xA;which accompanies this distribution, and is available at&#xD;&#xA;http://www.eclipse.org/legal/epl-2.0&#xD;&#xA;&#xD;&#xA;Contributors:&#xD;&#xA;   SAP AG - initial API, implementation and documentation&#xD;&#xA;&#xD;&#xA;&lt;/copyright>"
     modelDirectory="/org.eclipse.graphiti.mm/src-gen" modelPluginID="org.eclipse.graphiti.mm"
     modelName="Graphiti" editPluginClass="org.eclipse.graphiti.mm.edit.GraphitiEditPlugin"
     editorPluginClass="org.eclipse.graphiti.mm.editor.GraphitiEditorPlugin" importerID="org.eclipse.emf.importer.ecore"
diff --git a/plugins/org.eclipse.graphiti.mm/plugin.properties b/plugins/org.eclipse.graphiti.mm/plugin.properties
index 490188a..9198dc4 100644
--- a/plugins/org.eclipse.graphiti.mm/plugin.properties
+++ b/plugins/org.eclipse.graphiti.mm/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Notational Model (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/plugins/org.eclipse.graphiti.mm/plugin.xml b/plugins/org.eclipse.graphiti.mm/plugin.xml
index b2b7e71..b566e39 100644
--- a/plugins/org.eclipse.graphiti.mm/plugin.xml
+++ b/plugins/org.eclipse.graphiti.mm/plugin.xml
@@ -2,18 +2,18 @@
 <?eclipse version="3.0"?>
 
 <!--
- <copyright>
- 
- Copyright (c) 2005, 2010 SAP AG.
- 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:
-    SAP AG - initial API, implementation and documentation
- 
- </copyright>
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
 -->
 
 <plugin>
diff --git a/plugins/org.eclipse.graphiti.mm/pom.xml b/plugins/org.eclipse.graphiti.mm/pom.xml
index 19c013b..7d4ca5f 100644
--- a/plugins/org.eclipse.graphiti.mm/pom.xml
+++ b/plugins/org.eclipse.graphiti.mm/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/GraphicsAlgorithmContainer.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/GraphicsAlgorithmContainer.java
index b465513..b132d77 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/GraphicsAlgorithmContainer.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/GraphicsAlgorithmContainer.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmFactory.java
index 14a35dd..dce66ba 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmFactory.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm;
 
 import org.eclipse.emf.ecore.EFactory;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmPackage.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmPackage.java
index 43b9b6a..c95a93f 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmPackage.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/MmPackage.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/Property.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/Property.java
index b803d95..6ce7fc2 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/Property.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/Property.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/PropertyContainer.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/PropertyContainer.java
index 6270083..5dd05fd 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/PropertyContainer.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/PropertyContainer.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/StyleContainer.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/StyleContainer.java
index 5ebc3bf..be13221 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/StyleContainer.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/StyleContainer.java
@@ -1,23 +1,19 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Style;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AbstractText.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AbstractText.java
index b3d521a..78bb2f7 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AbstractText.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AbstractText.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsFactory.java
index ddf7a71..8c2e2e7 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsFactory.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 import org.eclipse.emf.ecore.EFactory;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsPackage.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsPackage.java
index b8abf75..7fa4eec 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsPackage.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/AlgorithmsPackage.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Ellipse.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Ellipse.java
index 16f9d60..811286a 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Ellipse.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Ellipse.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/GraphicsAlgorithm.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/GraphicsAlgorithm.java
index 2851b89..ac10133 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/GraphicsAlgorithm.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/GraphicsAlgorithm.java
@@ -1,26 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
-
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.Style;
-
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Image.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Image.java
index b65139a..de2882b 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Image.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Image.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/MultiText.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/MultiText.java
index 8ca639b..8ae9966 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/MultiText.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/MultiText.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/PlatformGraphicsAlgorithm.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/PlatformGraphicsAlgorithm.java
index 9116403..f5c7b5b 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/PlatformGraphicsAlgorithm.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/PlatformGraphicsAlgorithm.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polygon.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polygon.java
index f6fd403..9d11253 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polygon.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polygon.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polyline.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polyline.java
index 7c20dfd..4940197 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polyline.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Polyline.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Rectangle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Rectangle.java
index 7d4af53..3476e62 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Rectangle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Rectangle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/RoundedRectangle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/RoundedRectangle.java
index 16c071f..d995c40 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/RoundedRectangle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/RoundedRectangle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Text.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Text.java
index dd0ab16..71ff801 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Text.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/Text.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AbstractTextImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AbstractTextImpl.java
index 02d6c13..2cd4f9d 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AbstractTextImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AbstractTextImpl.java
@@ -1,19 +1,17 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- *    Robert Brodt (mwenz) - Bug 440796 - AbstractText.setRotation() sends incorrect notification to transaction change recorder
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*    Robert Brodt (mwenz) - Bug 440796 - AbstractText.setRotation() sends incorrect notification to transaction change recorder
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsFactoryImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsFactoryImpl.java
index 07eac6c..7732caa 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsFactoryImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsFactoryImpl.java
@@ -1,28 +1,33 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
-
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-
-import org.eclipse.graphiti.mm.algorithms.*;
+import org.eclipse.graphiti.mm.algorithms.AlgorithmsFactory;
+import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
+import org.eclipse.graphiti.mm.algorithms.Ellipse;
+import org.eclipse.graphiti.mm.algorithms.Image;
+import org.eclipse.graphiti.mm.algorithms.MultiText;
+import org.eclipse.graphiti.mm.algorithms.PlatformGraphicsAlgorithm;
+import org.eclipse.graphiti.mm.algorithms.Polygon;
+import org.eclipse.graphiti.mm.algorithms.Polyline;
+import org.eclipse.graphiti.mm.algorithms.Rectangle;
+import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
+import org.eclipse.graphiti.mm.algorithms.Text;
 
 /**
  * <!-- begin-user-doc -->
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsPackageImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsPackageImpl.java
index c49c4ab..a94be7a 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsPackageImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/AlgorithmsPackageImpl.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/EllipseImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/EllipseImpl.java
index d888297..0a1c728 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/EllipseImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/EllipseImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Ellipse;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/GraphicsAlgorithmImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/GraphicsAlgorithmImpl.java
index 0bb1c79..65d5574 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/GraphicsAlgorithmImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/GraphicsAlgorithmImpl.java
@@ -1,47 +1,37 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
-
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
 import org.eclipse.graphiti.mm.algorithms.styles.LineStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.RenderingStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.Style;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
-
 import org.eclipse.graphiti.mm.impl.GraphicsAlgorithmContainerImpl;
-
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/ImageImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/ImageImpl.java
index 39bf871..8292c6c 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/ImageImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/ImageImpl.java
@@ -1,25 +1,20 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Image;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/MultiTextImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/MultiTextImpl.java
index 6e2045f..cff5318 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/MultiTextImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/MultiTextImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.MultiText;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PlatformGraphicsAlgorithmImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PlatformGraphicsAlgorithmImpl.java
index bcb2ee2..858b8b8 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PlatformGraphicsAlgorithmImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PlatformGraphicsAlgorithmImpl.java
@@ -1,25 +1,20 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.PlatformGraphicsAlgorithm;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolygonImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolygonImpl.java
index 12721fe..76b8210 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolygonImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolygonImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Polygon;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolylineImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolylineImpl.java
index f63330c..87795c6 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolylineImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/PolylineImpl.java
@@ -1,34 +1,27 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Polyline;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RectangleImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RectangleImpl.java
index 4e3bed2..b8ac83c 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RectangleImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RectangleImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Rectangle;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RoundedRectangleImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RoundedRectangleImpl.java
index 242f611..72a96cc 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RoundedRectangleImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/RoundedRectangleImpl.java
@@ -1,25 +1,20 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/TextImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/TextImpl.java
index de93951..e305033 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/TextImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/impl/TextImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Text;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AbstractStyle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AbstractStyle.java
index 4578a6f..cec7af2 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AbstractStyle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AbstractStyle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AdaptedGradientColoredAreas.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AdaptedGradientColoredAreas.java
index e54d48e..0aee2bf 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AdaptedGradientColoredAreas.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/AdaptedGradientColoredAreas.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Color.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Color.java
index 8be393d..c94dc05 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Color.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Color.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Font.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Font.java
index 07b82c7..347ce4d 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Font.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Font.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredArea.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredArea.java
index 8aa6f0b..3ba2880 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredArea.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredArea.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredAreas.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredAreas.java
index ece1887..f4fd701 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredAreas.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredAreas.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredLocation.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredLocation.java
index 938f5bc..1b2eea4 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredLocation.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/GradientColoredLocation.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LineStyle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LineStyle.java
index f9d1962..be8c203 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LineStyle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LineStyle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import java.util.Arrays;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LocationType.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LocationType.java
index 644eada..00eb91a 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LocationType.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/LocationType.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import java.util.Arrays;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Orientation.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Orientation.java
index 3dac032..1d6e04b 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Orientation.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Orientation.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import java.util.Arrays;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Point.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Point.java
index 2b5a1b5..709b961 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Point.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Point.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/PrecisionPoint.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/PrecisionPoint.java
index 496c552..7568554 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/PrecisionPoint.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/PrecisionPoint.java
@@ -1,18 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/RenderingStyle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/RenderingStyle.java
index 5d27dde..e33622f 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/RenderingStyle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/RenderingStyle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Style.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Style.java
index fcaca1e..6b2a369 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Style.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/Style.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.graphiti.mm.StyleContainer;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesFactory.java
index 63a5fd9..99657e5 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesFactory.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EFactory;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesPackage.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesPackage.java
index 338789b..d04b084 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesPackage.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/StylesPackage.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyle.java
index f856988..5d093f7 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyleRegion.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyleRegion.java
index 501c547..edaf9bf 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyleRegion.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/TextStyleRegion.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/UnderlineStyle.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/UnderlineStyle.java
index ccd2dc9..f6304b4 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/UnderlineStyle.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/UnderlineStyle.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles;
 
 import java.util.Arrays;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AbstractStyleImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AbstractStyleImpl.java
index 466804d..ef27b70 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AbstractStyleImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AbstractStyleImpl.java
@@ -1,28 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
 import org.eclipse.graphiti.mm.algorithms.styles.LineStyle;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AdaptedGradientColoredAreasImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AdaptedGradientColoredAreasImpl.java
index 001795f..3eaf891 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AdaptedGradientColoredAreasImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/AdaptedGradientColoredAreasImpl.java
@@ -1,35 +1,28 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/ColorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/ColorImpl.java
index bd4bd59..e0bed52 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/ColorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/ColorImpl.java
@@ -1,26 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/FontImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/FontImpl.java
index 8f322dd..d7e5d44 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/FontImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/FontImpl.java
@@ -1,26 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Font;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreaImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreaImpl.java
index 8492ffe..63e18c3 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreaImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreaImpl.java
@@ -1,28 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredArea;
 import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredLocation;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreasImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreasImpl.java
index a36e723..65a594e 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreasImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredAreasImpl.java
@@ -1,35 +1,28 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredArea;
 import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredLocationImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredLocationImpl.java
index fb95132..dd06bd8 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredLocationImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/GradientColoredLocationImpl.java
@@ -1,28 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
 import org.eclipse.graphiti.mm.algorithms.styles.GradientColoredLocation;
 import org.eclipse.graphiti.mm.algorithms.styles.LocationType;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PointImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PointImpl.java
index 86e8f28..08ac8fe 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PointImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PointImpl.java
@@ -1,26 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PrecisionPointImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PrecisionPointImpl.java
index ce8b47c..4c61e1c 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PrecisionPointImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/PrecisionPointImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/RenderingStyleImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/RenderingStyleImpl.java
index b381149..3fb26b1 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/RenderingStyleImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/RenderingStyleImpl.java
@@ -1,28 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.RenderingStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StyleImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StyleImpl.java
index c58e390..fc2fb3c 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StyleImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StyleImpl.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesFactoryImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesFactoryImpl.java
index 22d1c7a..c3f1482 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesFactoryImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesFactoryImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.ecore.EClass;
@@ -20,7 +18,6 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-import org.eclipse.graphiti.mm.algorithms.styles.*;
 import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
 import org.eclipse.graphiti.mm.algorithms.styles.Font;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesPackageImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesPackageImpl.java
index 0f75877..8b87f54 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesPackageImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/StylesPackageImpl.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleImpl.java
index 2b0d575..50c9f20 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleRegionImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleRegionImpl.java
index 6fe6af9..8b731d3 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleRegionImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/impl/TextStyleRegionImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.impl;
 
 import org.eclipse.emf.common.notify.Notification;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesAdapterFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesAdapterFactory.java
index d463718..7c70095 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesAdapterFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesAdapterFactory.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.util;
 
 import org.eclipse.emf.common.notify.Adapter;
@@ -19,7 +17,6 @@
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.graphiti.mm.StyleContainer;
-import org.eclipse.graphiti.mm.algorithms.styles.*;
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesSwitch.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesSwitch.java
index 57a5f8e..4024afb 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesSwitch.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/styles/util/StylesSwitch.java
@@ -1,24 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.styles.util;
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.util.Switch;
 import org.eclipse.graphiti.mm.StyleContainer;
-import org.eclipse.graphiti.mm.algorithms.styles.*;
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
 import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
 import org.eclipse.graphiti.mm.algorithms.styles.Color;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsAdapterFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsAdapterFactory.java
index a310358..c3cf110 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsAdapterFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsAdapterFactory.java
@@ -1,31 +1,35 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.util;
 
 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.Notifier;
-
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-
 import org.eclipse.emf.ecore.EObject;
-
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.PropertyContainer;
-
-import org.eclipse.graphiti.mm.algorithms.*;
-
+import org.eclipse.graphiti.mm.algorithms.AbstractText;
+import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
+import org.eclipse.graphiti.mm.algorithms.Ellipse;
+import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
+import org.eclipse.graphiti.mm.algorithms.Image;
+import org.eclipse.graphiti.mm.algorithms.MultiText;
+import org.eclipse.graphiti.mm.algorithms.PlatformGraphicsAlgorithm;
+import org.eclipse.graphiti.mm.algorithms.Polygon;
+import org.eclipse.graphiti.mm.algorithms.Polyline;
+import org.eclipse.graphiti.mm.algorithms.Rectangle;
+import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
+import org.eclipse.graphiti.mm.algorithms.Text;
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsSwitch.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsSwitch.java
index a2154f4..b5a97f7 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsSwitch.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/algorithms/util/AlgorithmsSwitch.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.algorithms.util;
 
 
@@ -20,7 +18,6 @@
 import org.eclipse.emf.ecore.util.Switch;
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.PropertyContainer;
-import org.eclipse.graphiti.mm.algorithms.*;
 import org.eclipse.graphiti.mm.algorithms.AbstractText;
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.Ellipse;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/GraphicsAlgorithmContainerImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/GraphicsAlgorithmContainerImpl.java
index 50e52ee..87269ed 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/GraphicsAlgorithmContainerImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/GraphicsAlgorithmContainerImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.MmPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmFactoryImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmFactoryImpl.java
index 27c3045..755aad2 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmFactoryImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmFactoryImpl.java
@@ -1,28 +1,25 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.impl;
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
-
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
-
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-
-import org.eclipse.graphiti.mm.*;
+import org.eclipse.graphiti.mm.MmFactory;
+import org.eclipse.graphiti.mm.MmPackage;
+import org.eclipse.graphiti.mm.Property;
 
 /**
  * <!-- begin-user-doc -->
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmPackageImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmPackageImpl.java
index e053fb2..7d66c73 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmPackageImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/MmPackageImpl.java
@@ -1,43 +1,33 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.impl;
 
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
-
 import org.eclipse.emf.ecore.impl.EPackageImpl;
-
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.MmFactory;
 import org.eclipse.graphiti.mm.MmPackage;
 import org.eclipse.graphiti.mm.Property;
 import org.eclipse.graphiti.mm.PropertyContainer;
 import org.eclipse.graphiti.mm.StyleContainer;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
-
 import org.eclipse.graphiti.mm.algorithms.impl.AlgorithmsPackageImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
-
 import org.eclipse.graphiti.mm.algorithms.styles.impl.StylesPackageImpl;
-
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
-
 import org.eclipse.graphiti.mm.pictograms.impl.PictogramsPackageImpl;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyContainerImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyContainerImpl.java
index 2f19f4b..c2f0aef 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyContainerImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyContainerImpl.java
@@ -1,33 +1,26 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.MmPackage;
 import org.eclipse.graphiti.mm.Property;
 import org.eclipse.graphiti.mm.PropertyContainer;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyImpl.java
index b9f206a..80adf75 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/PropertyImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.impl;
 
 import org.eclipse.emf.common.notify.Notification;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/StyleContainerImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/StyleContainerImpl.java
index eec25ce..44a64e2 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/StyleContainerImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/impl/StyleContainerImpl.java
@@ -1,36 +1,28 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.EObjectImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.MmPackage;
 import org.eclipse.graphiti.mm.StyleContainer;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Style;
 import org.eclipse.graphiti.mm.algorithms.styles.StylesPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AdvancedAnchor.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AdvancedAnchor.java
index 886e7f9..b6ed375 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AdvancedAnchor.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AdvancedAnchor.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Anchor.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Anchor.java
index 0312665..fba095e 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Anchor.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Anchor.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AnchorContainer.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AnchorContainer.java
index 4461ac0..99fcfb9 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AnchorContainer.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/AnchorContainer.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/BoxRelativeAnchor.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/BoxRelativeAnchor.java
index 7fa8da9..dec94da 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/BoxRelativeAnchor.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/BoxRelativeAnchor.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ChopboxAnchor.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ChopboxAnchor.java
index 8b2d6e7..1b2716e 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ChopboxAnchor.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ChopboxAnchor.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CompositeConnection.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CompositeConnection.java
index ab84acb..34655cb 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CompositeConnection.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CompositeConnection.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    Benjamin Schmeling - initial API, implementation and documentation for Bug 367483
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Benjamin Schmeling - initial API, implementation and documentation for Bug 367483
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Connection.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Connection.java
index 88a4bd6..b84eff7 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Connection.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Connection.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ConnectionDecorator.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ConnectionDecorator.java
index 15ce275..7706cb4 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ConnectionDecorator.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ConnectionDecorator.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ContainerShape.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ContainerShape.java
index b769678..e54a510 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ContainerShape.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ContainerShape.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CurvedConnection.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CurvedConnection.java
index 5c0c347..dc19cf6 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CurvedConnection.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/CurvedConnection.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Diagram.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Diagram.java
index ccb9df4..09e48d8 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Diagram.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Diagram.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FixPointAnchor.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FixPointAnchor.java
index f83605e..3c4868a 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FixPointAnchor.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FixPointAnchor.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FreeFormConnection.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FreeFormConnection.java
index 90090de..6bb27b8 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FreeFormConnection.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/FreeFormConnection.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ManhattanConnection.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ManhattanConnection.java
index 4c00d22..afb2eb5 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ManhattanConnection.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/ManhattanConnection.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramElement.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramElement.java
index 8fd11b0..5e30db1 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramElement.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramElement.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
-
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramLink.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramLink.java
index b9787d5..fca9b80 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramLink.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramLink.java
@@ -1,23 +1,19 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EObject;
-
 import org.eclipse.graphiti.mm.PropertyContainer;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsFactory.java
index de46b3b..089a47c 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsFactory.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 import org.eclipse.emf.ecore.EFactory;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsPackage.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsPackage.java
index cd78ebd..c399bf7 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsPackage.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/PictogramsPackage.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Shape.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Shape.java
index 1903042..e4523c4 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Shape.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/Shape.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms;
 
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AdvancedAnchorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AdvancedAnchorImpl.java
index fadba77..643146d 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AdvancedAnchorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AdvancedAnchorImpl.java
@@ -1,25 +1,20 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.pictograms.AdvancedAnchor;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorContainerImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorContainerImpl.java
index c0d7695..3969fb3 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorContainerImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorContainerImpl.java
@@ -1,31 +1,25 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorImpl.java
index 092d286..2de3713 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/AnchorImpl.java
@@ -1,37 +1,29 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
-
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
 import org.eclipse.graphiti.mm.pictograms.Connection;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/BoxRelativeAnchorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/BoxRelativeAnchorImpl.java
index ac2288b..05ecdf6 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/BoxRelativeAnchorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/BoxRelativeAnchorImpl.java
@@ -1,25 +1,20 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
-
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.pictograms.BoxRelativeAnchor;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ChopboxAnchorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ChopboxAnchorImpl.java
index db7a71e..3f0b6f4 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ChopboxAnchorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ChopboxAnchorImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.pictograms.ChopboxAnchor;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CompositeConnectionImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CompositeConnectionImpl.java
index 938dc56..35a1511 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CompositeConnectionImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CompositeConnectionImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    Benjamin Schmeling - initial API, implementation and documentation for Bug 367483
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Benjamin Schmeling - initial API, implementation and documentation for Bug 367483
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionDecoratorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionDecoratorImpl.java
index f192c48..c85d688 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionDecoratorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionDecoratorImpl.java
@@ -1,29 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.emf.ecore.util.EcoreUtil;
-
 import org.eclipse.graphiti.mm.pictograms.Connection;
 import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionImpl.java
index 6f35912..d0c517d 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ConnectionImpl.java
@@ -1,35 +1,28 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.Connection;
 import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ContainerShapeImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ContainerShapeImpl.java
index 22f0a12..f4b9385 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ContainerShapeImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ContainerShapeImpl.java
@@ -1,31 +1,25 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.pictograms.ContainerShape;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 import org.eclipse.graphiti.mm.pictograms.Shape;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CurvedConnectionImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CurvedConnectionImpl.java
index 2a43b24..bb24224 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CurvedConnectionImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/CurvedConnectionImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/DiagramImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/DiagramImpl.java
index f11bf51..9c11a30 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/DiagramImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/DiagramImpl.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FixPointAnchorImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FixPointAnchorImpl.java
index 57e2842..a31b91b 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FixPointAnchorImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FixPointAnchorImpl.java
@@ -1,29 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
-
 import org.eclipse.graphiti.mm.pictograms.FixPointAnchor;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FreeFormConnectionImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FreeFormConnectionImpl.java
index ecd6dd2..98081fc 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FreeFormConnectionImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/FreeFormConnectionImpl.java
@@ -1,33 +1,26 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.emf.ecore.util.InternalEList;
-
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
-
 import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ManhattanConnectionImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ManhattanConnectionImpl.java
index 9a552b9..2d1fa5a 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ManhattanConnectionImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ManhattanConnectionImpl.java
@@ -1,21 +1,18 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.ecore.EClass;
-
 import org.eclipse.graphiti.mm.pictograms.ManhattanConnection;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramElementImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramElementImpl.java
index 224299d..a7ee919 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramElementImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramElementImpl.java
@@ -1,32 +1,25 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.graphiti.mm.algorithms.AlgorithmsPackage;
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
-
 import org.eclipse.graphiti.mm.impl.GraphicsAlgorithmContainerImpl;
-
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.mm.pictograms.PictogramLink;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramLinkImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramLinkImpl.java
index 0432609..bf1688f 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramLinkImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramLinkImpl.java
@@ -1,37 +1,29 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import java.util.Collection;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.common.util.EList;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.emf.ecore.util.EObjectResolvingEList;
 import org.eclipse.emf.ecore.util.EcoreUtil;
-
 import org.eclipse.graphiti.mm.impl.PropertyContainerImpl;
-
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.mm.pictograms.PictogramLink;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsFactoryImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsFactoryImpl.java
index 8088d4a..83ee79b 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsFactoryImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsFactoryImpl.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.ecore.EClass;
@@ -20,7 +18,6 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
-import org.eclipse.graphiti.mm.pictograms.*;
 import org.eclipse.graphiti.mm.pictograms.BoxRelativeAnchor;
 import org.eclipse.graphiti.mm.pictograms.ChopboxAnchor;
 import org.eclipse.graphiti.mm.pictograms.CompositeConnection;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsPackageImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsPackageImpl.java
index 1029dde..66c4659 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsPackageImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/PictogramsPackageImpl.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ShapeImpl.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ShapeImpl.java
index f0e6713..3baaf11 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ShapeImpl.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/impl/ShapeImpl.java
@@ -1,29 +1,23 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.impl;
 
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.NotificationChain;
-
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.InternalEObject;
-
 import org.eclipse.emf.ecore.impl.ENotificationImpl;
-
 import org.eclipse.emf.ecore.util.EcoreUtil;
-
 import org.eclipse.graphiti.mm.pictograms.ContainerShape;
 import org.eclipse.graphiti.mm.pictograms.PictogramsPackage;
 import org.eclipse.graphiti.mm.pictograms.Shape;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsAdapterFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsAdapterFactory.java
index f84c9c0..38c099c 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsAdapterFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsAdapterFactory.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.util;
 
 import org.eclipse.emf.common.notify.Adapter;
@@ -22,7 +20,6 @@
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.PropertyContainer;
 import org.eclipse.graphiti.mm.StyleContainer;
-import org.eclipse.graphiti.mm.pictograms.*;
 import org.eclipse.graphiti.mm.pictograms.AdvancedAnchor;
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsSwitch.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsSwitch.java
index f57a58d..d2a1c4b 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsSwitch.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/pictograms/util/PictogramsSwitch.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.pictograms.util;
 
 
@@ -22,7 +20,6 @@
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.PropertyContainer;
 import org.eclipse.graphiti.mm.StyleContainer;
-import org.eclipse.graphiti.mm.pictograms.*;
 import org.eclipse.graphiti.mm.pictograms.AdvancedAnchor;
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmAdapterFactory.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmAdapterFactory.java
index 9086826..c0aa10d 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmAdapterFactory.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmAdapterFactory.java
@@ -1,27 +1,26 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.util;
 
 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.Notifier;
-
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-
 import org.eclipse.emf.ecore.EObject;
-
-import org.eclipse.graphiti.mm.*;
+import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
+import org.eclipse.graphiti.mm.MmPackage;
+import org.eclipse.graphiti.mm.Property;
+import org.eclipse.graphiti.mm.PropertyContainer;
+import org.eclipse.graphiti.mm.StyleContainer;
 
 /**
  * <!-- begin-user-doc -->
diff --git a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmSwitch.java b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmSwitch.java
index 183882e..45be460 100644
--- a/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmSwitch.java
+++ b/plugins/org.eclipse.graphiti.mm/src-gen/org/eclipse/graphiti/mm/util/MmSwitch.java
@@ -1,24 +1,21 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.mm.util;
 
 
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.util.Switch;
-import org.eclipse.graphiti.mm.*;
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.MmPackage;
 import org.eclipse.graphiti.mm.Property;
diff --git a/plugins/org.eclipse.graphiti.pattern/about.html b/plugins/org.eclipse.graphiti.pattern/about.html
index c258ef5..38cecbb 100644
--- a/plugins/org.eclipse.graphiti.pattern/about.html
+++ b/plugins/org.eclipse.graphiti.pattern/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/plugins/org.eclipse.graphiti.pattern/build.properties b/plugins/org.eclipse.graphiti.pattern/build.properties
index 9c888a9..2f04876 100644
--- a/plugins/org.eclipse.graphiti.pattern/build.properties
+++ b/plugins/org.eclipse.graphiti.pattern/build.properties
@@ -1,23 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
-
-# <copyright>
-# </copyright>
-#
-# $Id: build.properties,v 1.2 2010/07/21 07:21:35 mwenz Exp $
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 bin.includes = .,\
                META-INF/,\
diff --git a/plugins/org.eclipse.graphiti.pattern/plugin.properties b/plugins/org.eclipse.graphiti.pattern/plugin.properties
index d6a3b60..c284dab 100644
--- a/plugins/org.eclipse.graphiti.pattern/plugin.properties
+++ b/plugins/org.eclipse.graphiti.pattern/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Pattern (Incubation)
 providerName = Eclipse Modeling Project
diff --git a/plugins/org.eclipse.graphiti.pattern/pom.xml b/plugins/org.eclipse.graphiti.pattern/pom.xml
index 8c14099..fc628f4 100644
--- a/plugins/org.eclipse.graphiti.pattern/pom.xml
+++ b/plugins/org.eclipse.graphiti.pattern/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractBasePattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractBasePattern.java
index 6403208..c903889 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractBasePattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractBasePattern.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.IAddFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractConnectionPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractConnectionPattern.java
index f82ecdd..4ad35cd 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractConnectionPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractConnectionPattern.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 329517 - state call backs during creation of a connection
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 329517 - state call backs during creation of a connection
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.context.IConnectionContext;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractPattern.java
index d9b2c1b..54d8609 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AbstractPattern.java
@@ -1,26 +1,23 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *    cbrand - Bug 385190 - Introduce constructor without parameters for patterns
- *    mwenz - Bug 390331 - preDelete and postDelete not called for Patterns
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*    cbrand - Bug 385190 - Introduce constructor without parameters for patterns
+*    mwenz - Bug 390331 - preDelete and postDelete not called for Patterns
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AddFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AddFeatureForPattern.java
index d0e4c1c..f5bec62 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AddFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/AddFeatureForPattern.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateConnectionFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateConnectionFeatureForPattern.java
index 22006d9..227cba1 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateConnectionFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateConnectionFeatureForPattern.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mgorning - Bug 329517 - state call backs during creation of a connection
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mgorning - Bug 329517 - state call backs during creation of a connection
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateFeatureForPattern.java
index 1559cc7..85e4911 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/CreateFeatureForPattern.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DefaultFeatureProviderWithPatterns.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DefaultFeatureProviderWithPatterns.java
index 811f39f..a186a21 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DefaultFeatureProviderWithPatterns.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DefaultFeatureProviderWithPatterns.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DeleteFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DeleteFeatureForPattern.java
index e551943..c468f19 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DeleteFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DeleteFeatureForPattern.java
@@ -1,27 +1,24 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2018 Volker Wegert 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:
- *    Volker Wegert - initial API, implementation and documentation:
- *                    Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 Volker Wegert and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Volker Wegert - initial API, implementation and documentation:
+*                    Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DirectEditingFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DirectEditingFeatureForPattern.java
index f1a8ea0..daf7338 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DirectEditingFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/DirectEditingFeatureForPattern.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/FeatureForPatternDelegate.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/FeatureForPatternDelegate.java
index a505e1a..d779604 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/FeatureForPatternDelegate.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/FeatureForPatternDelegate.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IConnectionPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IConnectionPattern.java
index e948f9d..e7fffcb 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IConnectionPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IConnectionPattern.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomAbortableUndoRedoPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomAbortableUndoRedoPattern.java
index 2faf33b..3cfa4e7 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomAbortableUndoRedoPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomAbortableUndoRedoPattern.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomUndoRedoPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomUndoRedoPattern.java
index b3d034f..608260d 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomUndoRedoPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ICustomUndoRedoPattern.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureForPattern.java
index bf03a06..b8c0767 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureForPattern.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureProviderWithPatterns.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureProviderWithPatterns.java
index 0c65c10..6586fc5 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureProviderWithPatterns.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IFeatureProviderWithPatterns.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPattern.java
index 86e3ff6..9ab24a6 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPattern.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *    Volker Wegert - Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*    Volker Wegert - Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.IAddFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPatternContainer.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPatternContainer.java
index 6cc2443..7b72802 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPatternContainer.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/IPatternContainer.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/LayoutFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/LayoutFeatureForPattern.java
index 1cb5fc2..cec8865 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/LayoutFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/LayoutFeatureForPattern.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/MoveShapeFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/MoveShapeFeatureForPattern.java
index bc5193d..f5ba46e 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/MoveShapeFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/MoveShapeFeatureForPattern.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ReconnectionFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ReconnectionFeatureForPattern.java
index 908a7a6..ed1e5df 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ReconnectionFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ReconnectionFeatureForPattern.java
@@ -1,25 +1,22 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mlypik - Bug 401792 - Disable starting reconnection
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mlypik - Bug 401792 - Disable starting reconnection
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/RemoveFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/RemoveFeatureForPattern.java
index 8ef1297..8d4bbb7 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/RemoveFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/RemoveFeatureForPattern.java
@@ -1,28 +1,25 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2018 Volker Wegert 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:
- *    Volker Wegert - initial API, implementation and documentation:
- *                    Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 390331 - preDelete and postDelete not called for Patterns 
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 Volker Wegert and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Volker Wegert - initial API, implementation and documentation:
+*                    Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 390331 - preDelete and postDelete not called for Patterns 
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ResizeShapeFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ResizeShapeFeatureForPattern.java
index f7c9211..a6a50aa 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ResizeShapeFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/ResizeShapeFeatureForPattern.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/TypedPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/TypedPattern.java
index 6967027..9d0d4a1 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/TypedPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/TypedPattern.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/UpdateFeatureForPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/UpdateFeatureForPattern.java
index 916eeb4..3e02773 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/UpdateFeatureForPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/UpdateFeatureForPattern.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 481994 - Some XxxFeatureForPattern classes call ICustomUndoablePattern#redo instead of ICustomUndoRedoPattern#postRedo
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern;
 
 import org.eclipse.graphiti.features.ICustomAbortableUndoRedoFeature;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IColorConfiguration.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IColorConfiguration.java
index 8da17f3..63d3a14 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IColorConfiguration.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IColorConfiguration.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.config;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IIndentConfiguration.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IIndentConfiguration.java
index c3b09fb..5430911 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IIndentConfiguration.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IIndentConfiguration.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.config;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IMinimumSizeConfiguration.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IMinimumSizeConfiguration.java
index 4cfaf32..cefbc6a 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IMinimumSizeConfiguration.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IMinimumSizeConfiguration.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.config;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IPatternConfiguration.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IPatternConfiguration.java
index a3b7858..79a5a08 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IPatternConfiguration.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/config/IPatternConfiguration.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.config;
 
 import org.eclipse.graphiti.pattern.AbstractPattern;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdLayoutContext.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdLayoutContext.java
index 59f62f1..d4df84e 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdLayoutContext.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdLayoutContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.id;
 
 import org.eclipse.graphiti.features.context.impl.LayoutContext;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdPattern.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdPattern.java
index e129727..681c8d4 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdPattern.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdPattern.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 416708 - IdPattern canDirectEdit method disallows direct editing in case the id is set for the pictogram element
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 416708 - IdPattern canDirectEdit method disallows direct editing in case the id is set for the pictogram element
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.id;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdUpdateContext.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdUpdateContext.java
index 4944cad..bbd5c2e 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdUpdateContext.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/id/IdUpdateContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.id;
 
 import org.eclipse.graphiti.features.context.impl.UpdateContext;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/internal/T.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/internal/T.java
index d30a43f..a725a34 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/internal/T.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/internal/T.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.internal;
 
 import org.eclipse.graphiti.internal.util.AbstractTracer;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/ILinkCreationInfo.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/ILinkCreationInfo.java
index 31524e6..64ead0f 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/ILinkCreationInfo.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/ILinkCreationInfo.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMapping.java
index d532346..16fc268 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import org.eclipse.graphiti.pattern.mapping.data.IDataMapping;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingGrid.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingGrid.java
index 8ab2b5d..1b5387f 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingGrid.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingGrid.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingMulti.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingMulti.java
index db7fd3d..f9e1736 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingMulti.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingMulti.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingSingle.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingSingle.java
index 37bdff5..2fb46e2 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingSingle.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/IStructureMappingSingle.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/LinkCreationInfo.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/LinkCreationInfo.java
index 0c97ba2..1ddcea9 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/LinkCreationInfo.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/LinkCreationInfo.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/MappingProviderProvider.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/MappingProviderProvider.java
index 16cfc34..5cdbddc 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/MappingProviderProvider.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/MappingProviderProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMapping.java
index 53d0e53..b4acc36 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingGrid.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingGrid.java
index 45121ad..10e29cc 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingGrid.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingGrid.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingMulti.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingMulti.java
index 5645072..a4fdbf0 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingMulti.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingMulti.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import java.util.Collections;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingSingle.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingSingle.java
index e868019..7bd323a 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingSingle.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/StructureMappingSingle.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/DataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/DataMapping.java
index 4b9c336..cd777dc 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/DataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/DataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IDataMapping.java
index a59170b..09e7cc1 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramLink;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IImageDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IImageDataMapping.java
index 1309afd..b5cb3b1 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IImageDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/IImageDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramLink;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ILabelDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ILabelDataMapping.java
index be9b7d5..eb1d0c3 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ILabelDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ILabelDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ITextDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ITextDataMapping.java
index f05e61d..2627273 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ITextDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ITextDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramLink;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ImageDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ImageDataMapping.java
index 87d9a34..19569f2 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ImageDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/ImageDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/LabelDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/LabelDataMapping.java
index cc4a652..3952ef6 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/LabelDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/LabelDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/TextDataMapping.java b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/TextDataMapping.java
index 1b6d375..f2a09c1 100644
--- a/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/TextDataMapping.java
+++ b/plugins/org.eclipse.graphiti.pattern/src/org/eclipse/graphiti/pattern/mapping/data/TextDataMapping.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 325084 - Provide documentation for Patterns
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 325084 - Provide documentation for Patterns
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.pattern.mapping.data;
 
 import org.eclipse.graphiti.features.IMappingProvider;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/about.html b/plugins/org.eclipse.graphiti.tools.newprojectwizard/about.html
index c258ef5..38cecbb 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/about.html
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/plugins/org.eclipse.graphiti.tools.newprojectwizard/build.properties b/plugins/org.eclipse.graphiti.tools.newprojectwizard/build.properties
index 8d33412..14010bd 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/build.properties
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/build.properties
@@ -1,3 +1,15 @@
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
+# Contributors:
+#    SAP SE - initial API, implementation and documentation
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.properties b/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.properties
index 16b0d53..37fbbca 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.properties
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
 #
-# Copyright (c) 2012, 2012 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti New Project Wizard (Incubation)
 providerName = Eclipse Modeling Project
 
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.xml b/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.xml
index e3c4c39..a1711e2 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.xml
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/plugin.xml
@@ -1,18 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2012, 2012 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
+**********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <plugin>
    <extension
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/pom.xml b/plugins/org.eclipse.graphiti.tools.newprojectwizard/pom.xml
index 6efcb68..08a3a39 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/pom.xml
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Activator.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Activator.java
index 72652b6..c71f133 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Activator.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Activator.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.ui.plugin.AbstractUIPlugin;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GraphitiEditorTemplateSection.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GraphitiEditorTemplateSection.java
index 9d058d9..276de12 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GraphitiEditorTemplateSection.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GraphitiEditorTemplateSection.java
@@ -1,18 +1,16 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 388211 - New plug-in with Graphiti editor wizard adds not needed dependency to org.eclipse.ui
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 388211 - New plug-in with Graphiti editor wizard adds not needed dependency to org.eclipse.ui
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import java.net.URL;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupOption.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupOption.java
index f2755d2..ffe42dd 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupOption.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupOption.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.pde.ui.templates.BaseOptionTemplateSection;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableBooleanOption.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableBooleanOption.java
index 769c4fc..99af5f6 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableBooleanOption.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableBooleanOption.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.pde.ui.templates.BaseOptionTemplateSection;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableStringOption.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableStringOption.java
index a4bc0b6..6dd6d65 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableStringOption.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/GroupableStringOption.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.pde.ui.templates.BaseOptionTemplateSection;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Messages.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Messages.java
index fbfe023..0493c22 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Messages.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/Messages.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.osgi.util.NLS;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/NewGraphitiEditorWizard.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/NewGraphitiEditorWizard.java
index 85be43f..0fbec1f 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/NewGraphitiEditorWizard.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/NewGraphitiEditorWizard.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.pde.ui.IFieldData;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/SelectTypeOption.java b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/SelectTypeOption.java
index 772387e..1e767c7 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/SelectTypeOption.java
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/SelectTypeOption.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tools.newprojectwizard.internal;
 
 import org.eclipse.core.resources.IProject;
diff --git a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/messages.properties b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/messages.properties
index d0e1689..2f93e38 100644
--- a/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/messages.properties
+++ b/plugins/org.eclipse.graphiti.tools.newprojectwizard/src/org/eclipse/graphiti/tools/newprojectwizard/internal/messages.properties
@@ -1,3 +1,16 @@
+######################################################################
+# Copyright (c) 2012, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
+# Contributors:
+#    SAP SE - initial API, implementation and documentation
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
+
 GraphitiEditorTemplateSection_fieldNameClassName=Class Name 
 GraphitiEditorTemplateSection_fieldNameConnectionDomainObject=Name
 GraphitiEditorTemplateSection_fieldNameDescription=Description
diff --git a/plugins/org.eclipse.graphiti.ui/about.html b/plugins/org.eclipse.graphiti.ui/about.html
index c258ef5..38cecbb 100644
--- a/plugins/org.eclipse.graphiti.ui/about.html
+++ b/plugins/org.eclipse.graphiti.ui/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/plugins/org.eclipse.graphiti.ui/about.properties b/plugins/org.eclipse.graphiti.ui/about.properties
index 1ca6a2b..8f5ca7f 100644
--- a/plugins/org.eclipse.graphiti.ui/about.properties
+++ b/plugins/org.eclipse.graphiti.ui/about.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 graphitiText = Graphiti - A Graphical Tool Development Framework\n\
 \n\
diff --git a/plugins/org.eclipse.graphiti.ui/build.properties b/plugins/org.eclipse.graphiti.ui/build.properties
index a7f91db..e250003 100644
--- a/plugins/org.eclipse.graphiti.ui/build.properties
+++ b/plugins/org.eclipse.graphiti.ui/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 bin.includes = .,\
                META-INF/,\
diff --git a/plugins/org.eclipse.graphiti.ui/plugin.properties b/plugins/org.eclipse.graphiti.ui/plugin.properties
index 693c7a5..e3bdb46 100644
--- a/plugins/org.eclipse.graphiti.ui/plugin.properties
+++ b/plugins/org.eclipse.graphiti.ui/plugin.properties
@@ -1,19 +1,16 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2011 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti UI (Incubation)
 providerName = Eclipse Modeling Project 
 
diff --git a/plugins/org.eclipse.graphiti.ui/plugin.xml b/plugins/org.eclipse.graphiti.ui/plugin.xml
index e785e62..17d3a28 100644
--- a/plugins/org.eclipse.graphiti.ui/plugin.xml
+++ b/plugins/org.eclipse.graphiti.ui/plugin.xml
@@ -1,21 +1,20 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2011 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-       Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
-       Laurent Le Moux, mwenz - Bug 423018 - Direct Graphiti diagram exporter
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    Laurent Le Moux, mwenz - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/plugins/org.eclipse.graphiti.ui/pom.xml b/plugins/org.eclipse.graphiti.ui/pom.xml
index aaa6321..52c800e 100644
--- a/plugins/org.eclipse.graphiti.ui/pom.xml
+++ b/plugins/org.eclipse.graphiti.ui/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultMarkerBehavior.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultMarkerBehavior.java
index 4c4665b..9a12c64 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultMarkerBehavior.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultMarkerBehavior.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2016 SAP AG.
- * 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:
- *    Bug 336488 - DiagramEditor API
- *    Felix Velasco - mwenz - Bug 379788 - Memory leak in DefaultMarkerBehavior
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 429215 - NPE in DefaultMarkerBehavior.dispose
- *    mwenz - Bug 497237 - NullPointerException in DefaultMarkerBehavior.dispose
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Bug 336488 - DiagramEditor API
+*    Felix Velasco - mwenz - Bug 379788 - Memory leak in DefaultMarkerBehavior
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 429215 - NPE in DefaultMarkerBehavior.dispose
+*    mwenz - Bug 497237 - NullPointerException in DefaultMarkerBehavior.dispose
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.LinkedHashMap;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPaletteBehavior.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPaletteBehavior.java
index b5ea573..778d0ff 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPaletteBehavior.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPaletteBehavior.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2016 SAP AG.
- * 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:
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 499428 - NullPointerException in DefaultPaletteBehavior$2$1.keyReleased
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 499428 - NullPointerException in DefaultPaletteBehavior$2$1.keyReleased
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.gef.EditDomain;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPersistencyBehavior.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPersistencyBehavior.java
index 1613480..81d0999 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPersistencyBehavior.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultPersistencyBehavior.java
@@ -1,26 +1,23 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2017 SAP AG.
- * 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:
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
- *    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
- *    mwenz - Bug 393074 - Save Editor Progress Monitor Argument
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz/Rob Cernich - Bug 391046 - Deadlock while saving prior to refactoring operation
- *    mwenz - Bug 437933 - NullPointerException in DefaultPersistencyBehavior.isDirty()
- *    mwenz - Bug 441676 - Read-only attribute is not respected in Graphiti
- *    mwenz - Bug 473087 - ClassCastException in DefaultPersistencyBehavior.loadDiagram
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
+*    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
+*    mwenz - Bug 393074 - Save Editor Progress Monitor Argument
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz/Rob Cernich - Bug 391046 - Deadlock while saving prior to refactoring operation
+*    mwenz - Bug 437933 - NullPointerException in DefaultPersistencyBehavior.isDirty()
+*    mwenz - Bug 441676 - Read-only attribute is not respected in Graphiti
+*    mwenz - Bug 473087 - ClassCastException in DefaultPersistencyBehavior.loadDiagram
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.lang.reflect.InvocationTargetException;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultRefreshBehavior.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultRefreshBehavior.java
index fc0902b..e5f4a02 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultRefreshBehavior.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultRefreshBehavior.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2017 SAP AG.
- * 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:
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 433779 - DiagramBehaviour.setInput() is not extensible
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *    Tamas Borbas - Bug 515645 - Missing API to turn off auto refresh
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 433779 - DiagramBehaviour.setInput() is not extensible
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*    Tamas Borbas - Bug 515645 - Missing API to turn off auto refresh
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.draw2d.Figure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultUpdateBehavior.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultUpdateBehavior.java
index 4982a60..60405ce 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultUpdateBehavior.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DefaultUpdateBehavior.java
@@ -1,28 +1,25 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    mwenz - Bug 347152 - Do not log diagnostics errors as errors in the Eclipse error log
- *    mwenz - Bug 359928 - DiagramEditorBehavior does not initialize adapterActive field
- *    Bug 336488 - DiagramEditor API - Rename from DiagramEditorBehavior to DefaultUpdateBehavior
- *    mwenz - Bug 389426 - Add factory method for creating EMF workspace synchronizer delegate
- *    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 427444 - Issues with drill-down diagram editor when diagram file is deleted
- *    mwenz - Bug 430687 - UpdateBehaviour createEditingDomain should be able to access diagram input (sphinx compatibility)
- *    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    mwenz - Bug 347152 - Do not log diagnostics errors as errors in the Eclipse error log
+*    mwenz - Bug 359928 - DiagramEditorBehavior does not initialize adapterActive field
+*    Bug 336488 - DiagramEditor API - Rename from DiagramEditorBehavior to DefaultUpdateBehavior
+*    mwenz - Bug 389426 - Add factory method for creating EMF workspace synchronizer delegate
+*    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 427444 - Issues with drill-down diagram editor when diagram file is deleted
+*    mwenz - Bug 430687 - UpdateBehaviour createEditingDomain should be able to access diagram input (sphinx compatibility)
+*    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramBehavior.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramBehavior.java
index 1777a7d..1433fb1 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramBehavior.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramBehavior.java
@@ -1,31 +1,29 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2016 SRC
- * 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:
- *    pjpaulin - Bug 352120 - Initial API, implementation and documentation
- *    mwenz - Bug 394315 - Enable injecting behavior objects in DiagramEditor
- *    mwenz - Bug 401859 - Graphiti DiagramEditor#dispose() does not release the editor related objects
- *    mwenz - Bug 407510 - Color background without Grid Layer turned to gray
- *    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
- *    mwenz - Bug 433650 - Editor in in dirty state after a Save
- *    mwenz - Bug 439689 - DiagramEdtior.setPictogramElementForSelection adds SelectionBorders to invisible PictogramElements
- *    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
- *    mwenz - Bug 433779 - DiagramBehaviour.setInput() is not extensible
- *    mwenz - Bug 470038 - NullPointerException in DiagramBehavior.unregisterDiagramResourceSetListener
- *    mwenz - Bug 470150 - NullPointerException in DiagramBehavior.getAdapter
- *    mwenz - Bug 477526 - NullPointerException in DiagramBehavior.addGefListeners
- *    mwenz - Bug 480961 - NullPointerException below ScrollingGraphicalViewer.reveal
- *	  edeley - Bug 498164 - Providing a JFace ResourceManager in DiagramBehavior to manage SWT resources
- *    mwenz - Bug 500851 - Probable NullPointerException in DiagramBehavior.disposeAfterGefDispose 
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2016, 2019 SRC
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    pjpaulin - Bug 352120 - Initial API, implementation and documentation
+*    mwenz - Bug 394315 - Enable injecting behavior objects in DiagramEditor
+*    mwenz - Bug 401859 - Graphiti DiagramEditor#dispose() does not release the editor related objects
+*    mwenz - Bug 407510 - Color background without Grid Layer turned to gray
+*    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
+*    mwenz - Bug 433650 - Editor in in dirty state after a Save
+*    mwenz - Bug 439689 - DiagramEdtior.setPictogramElementForSelection adds SelectionBorders to invisible PictogramElements
+*    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
+*    mwenz - Bug 433779 - DiagramBehaviour.setInput() is not extensible
+*    mwenz - Bug 470038 - NullPointerException in DiagramBehavior.unregisterDiagramResourceSetListener
+*    mwenz - Bug 470150 - NullPointerException in DiagramBehavior.getAdapter
+*    mwenz - Bug 477526 - NullPointerException in DiagramBehavior.addGefListeners
+*    mwenz - Bug 480961 - NullPointerException below ScrollingGraphicalViewer.reveal
+*	  edeley - Bug 498164 - Providing a JFace ResourceManager in DiagramBehavior to manage SWT resources
+*    mwenz - Bug 500851 - Probable NullPointerException in DiagramBehavior.disposeAfterGefDispose 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramComposite.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramComposite.java
index b5fea49..a6210cd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramComposite.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramComposite.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015 SRC
- * 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:
- *    pjpaulin - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 394315 - Enable injecting behavior objects in DiagramEditor
- *    pjpaulin - Bug 405314 - Should be able to override DefaultBehavior implementation without configuration
- *    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
- *    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2015, 2019 SRC
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    pjpaulin - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 394315 - Enable injecting behavior objects in DiagramEditor
+*    pjpaulin - Bug 405314 - Should be able to override DefaultBehavior implementation without configuration
+*    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
+*    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.core.runtime.IProgressMonitor;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditor.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditor.java
index 5099738..ab75d96 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditor.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditor.java
@@ -1,49 +1,46 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *    mwenz - Bug 332964: Enable setting selection for non-EMF domain models and
- *                        when embedded into a multi-page editor
- *    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    jpasch - Bug 323025 ActionBarContributor cleanup
- *    mwenz - Bug 345347 - There should be a way to not allow other plugins to contribute to the diagram context menu
- *    mwenz - Bug 346932 - Navigation history broken
- *    mwenz - Bug 356828 - Escaped diagram name is used as editor title
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
- *    mwenz - Bug 324556 - Prevent invisible shapes to be selected to avoid IllegalArgumentException
- *    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
- *    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
- *    Felix Velasco - mwenz - Bug 379788 - Memory leak in DefaultMarkerBehavior
- *    mwenz - Bug 387971 - Features cant't be invoked from contextMenu
- *    fvelasco - Bug 323349 - Enable external invocation of features
- *    mwenz - Bug 393113 - Auto-focus does not work for connections
- *    mwenz - Bug 396893 - Enable the registration of the drop target listeners configurable
- *    pjpaulin - Bug 352120 - Main implementation of DiagramEditor - API BREAKAGE HERE
- *    pjpaulin - Bug 352120 - Renamed from DiagramEditorImpl so that classes extending DiagramEditor do not break
- *    mwenz - Bug 394315 - Enable injecting behavior objects in DiagramEditor
- *    pjpaulin - Bug 405314 - Should be able to override DefaultBehavior implementation without configuration
- *    mwenz - Bug 430687 - UpdateBehaviour createEditingDomain should be able to access diagram input (sphinx compatibility)
- *    Hernan Gonzales (mwenz) - Bug 436601 - Race condition on save
- *    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
- *    mwenz - Bug 531207 - Prepare removal of deprecated CommandStackListener GEF interface
- *    mwenz - Bug 541017 - NullPointerException in DiagramEditor.selectionChanged
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*    mwenz - Bug 332964: Enable setting selection for non-EMF domain models and
+*                        when embedded into a multi-page editor
+*    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    jpasch - Bug 323025 ActionBarContributor cleanup
+*    mwenz - Bug 345347 - There should be a way to not allow other plugins to contribute to the diagram context menu
+*    mwenz - Bug 346932 - Navigation history broken
+*    mwenz - Bug 356828 - Escaped diagram name is used as editor title
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
+*    mwenz - Bug 324556 - Prevent invisible shapes to be selected to avoid IllegalArgumentException
+*    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
+*    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
+*    Felix Velasco - mwenz - Bug 379788 - Memory leak in DefaultMarkerBehavior
+*    mwenz - Bug 387971 - Features cant't be invoked from contextMenu
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*    mwenz - Bug 393113 - Auto-focus does not work for connections
+*    mwenz - Bug 396893 - Enable the registration of the drop target listeners configurable
+*    pjpaulin - Bug 352120 - Main implementation of DiagramEditor - API BREAKAGE HERE
+*    pjpaulin - Bug 352120 - Renamed from DiagramEditorImpl so that classes extending DiagramEditor do not break
+*    mwenz - Bug 394315 - Enable injecting behavior objects in DiagramEditor
+*    pjpaulin - Bug 405314 - Should be able to override DefaultBehavior implementation without configuration
+*    mwenz - Bug 430687 - UpdateBehaviour createEditingDomain should be able to access diagram input (sphinx compatibility)
+*    Hernan Gonzales (mwenz) - Bug 436601 - Race condition on save
+*    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
+*    mwenz - Bug 531207 - Prepare removal of deprecated CommandStackListener GEF interface
+*    mwenz - Bug 541017 - NullPointerException in DiagramEditor.selectionChanged
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorActionBarContributor.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorActionBarContributor.java
index 7391802..bee6afd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorActionBarContributor.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorActionBarContributor.java
@@ -1,26 +1,23 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
- *    jpasch - Bug 323025 ActionBarContributor cleanup
- *    mwenz - Fixed NPE in RCP usecase
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    mwenz - Bug 381437 - IllegalArgumentException when edit menu missing
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    mwenz - Bug 424636 - DiagramEditorActionBarContributor.contributeToMenu() throws IllegalArgumentException
- *    mwenz - Bug 450884 - View Menu Does not Have an ID
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
+*    jpasch - Bug 323025 ActionBarContributor cleanup
+*    mwenz - Fixed NPE in RCP usecase
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    mwenz - Bug 381437 - IllegalArgumentException when edit menu missing
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    mwenz - Bug 424636 - DiagramEditorActionBarContributor.contributeToMenu() throws IllegalArgumentException
+*    mwenz - Bug 450884 - View Menu Does not Have an ID
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.draw2d.PositionConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorContextMenuProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorContextMenuProvider.java
index 2389563..07dc788 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorContextMenuProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorContextMenuProvider.java
@@ -1,27 +1,24 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    mwenz - Bug 339525 - Enrich paste context with location information
- *    Bug 336488 - DiagramEditor API
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    cbrand - Bug 377783 - Dump for figures in connection layer needed
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    pjpaulin - Bug 352120 - Add certain menu options only if local transaction
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    mwenz - Bug 339525 - Enrich paste context with location information
+*    Bug 336488 - DiagramEditor API
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    cbrand - Bug 377783 - Dump for figures in connection layer needed
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    pjpaulin - Bug 352120 - Add certain menu options only if local transaction
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInput.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInput.java
index e40a95a..247793d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInput.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInput.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 346932 - Navigation history broken
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 378342 - Cannot store more than a diagram per file
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    fvelasco - Bug 415888 - DiagramEditorInput should adapt to IResource
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 346932 - Navigation history broken
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 378342 - Cannot store more than a diagram per file
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    fvelasco - Bug 415888 - DiagramEditorInput should adapt to IResource
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.core.resources.IFile;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInputFactory.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInputFactory.java
index d1a1619..d43941c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInputFactory.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorInputFactory.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
- *    mwenz - Bug 346932 - Navigation history broken
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
+*    mwenz - Bug 346932 - Navigation history broken
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.core.runtime.IAdaptable;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorMatchingStrategy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorMatchingStrategy.java
index 91e63b6..ca2d6fd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorMatchingStrategy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/DiagramEditorMatchingStrategy.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 378342 - Cannot store more than a diagram per file
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 378342 - Cannot store more than a diagram per file
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.core.resources.IFile;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/EditorInputAdapter.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/EditorInputAdapter.java
index f137b69..ed7e137 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/EditorInputAdapter.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/EditorInputAdapter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.core.resources.IFile;
@@ -22,6 +19,7 @@
 import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
 import org.eclipse.graphiti.ui.internal.util.ReflectionUtil;
 import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IFileEditorInput;
 
 /**
  * @since 0.9
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ElementDeleteListener.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ElementDeleteListener.java
index f7bb77d..6052d0d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ElementDeleteListener.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ElementDeleteListener.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.emf.common.notify.Notification;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/GraphicalComposite.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/GraphicalComposite.java
index fae8ea4..16de557 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/GraphicalComposite.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/GraphicalComposite.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015-2018 SRC, SAP SE
- * 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:
- *    pjpaulin - initial API, implementation and documentation
- *    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
- *    mwenz - Bug 531207 - Prepare removal of deprecated CommandStackListener GEF interface
- *    mwenz - Bug 541019 - NullPointerException in GraphicalComposite.selectionChanged
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2015, 2019 SRC, SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    pjpaulin - initial API, implementation and documentation
+*    jsivadier - Bug 467502 - Improve DiagramComposite implementation without IWorkbenchPart
+*    mwenz - Bug 531207 - Prepare removal of deprecated CommandStackListener GEF interface
+*    mwenz - Bug 541019 - NullPointerException in GraphicalComposite.selectionChanged
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramBehaviorUI.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramBehaviorUI.java
index c71c063..eb593cf 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramBehaviorUI.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramBehaviorUI.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramContainerUI.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramContainerUI.java
index a46a834..cf04f0a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramContainerUI.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramContainerUI.java
@@ -1,43 +1,39 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *    mwenz - Bug 332964: Enable setting selection for non-EMF domain models and
- *                        when embedded into a multi-page editor
- *    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    jpasch - Bug 323025 ActionBarContributor cleanup
- *    mwenz - Bug 345347 - There should be a way to not allow other plugins to contribute to the diagram context menu
- *    mwenz - Bug 346932 - Navigation history broken
- *    mwenz - Bug 356828 - Escaped diagram name is used as editor title
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
- *    mwenz - Bug 324556 - Prevent invisible shapes to be selected to avoid IllegalArgumentException
- *    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
- *    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
- *    Felix Velasco - mwenz - Bug 379788 - Memory leak in DefaultMarkerBehavior
- *    mwenz - Bug 387971 - Features cant't be invoked from contextMenu
- *    fvelasco - Bug 323349 - Enable external invocation of features
- *    mwenz - Bug 393113 - Auto-focus does not work for connections
- *    pjpaulin - Bug 352120 - Changed from a class to an interface - API BREAKAGE HERE
- *    pjpaulin - Bug 352120 - Renamed to IDiagramContainerUI so that DiagramEditor class can remain
- *    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
- *
- * </copyright>
- *
- *******************************************************************************/
-
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*    mwenz - Bug 332964: Enable setting selection for non-EMF domain models and
+*                        when embedded into a multi-page editor
+*    mwenz - Bug 336075 - DiagramEditor accepts URIEditorInput
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    jpasch - Bug 323025 ActionBarContributor cleanup
+*    mwenz - Bug 345347 - There should be a way to not allow other plugins to contribute to the diagram context menu
+*    mwenz - Bug 346932 - Navigation history broken
+*    mwenz - Bug 356828 - Escaped diagram name is used as editor title
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
+*    mwenz - Bug 324556 - Prevent invisible shapes to be selected to avoid IllegalArgumentException
+*    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
+*    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
+*    Felix Velasco - mwenz - Bug 379788 - Memory leak in DefaultMarkerBehavior
+*    mwenz - Bug 387971 - Features cant't be invoked from contextMenu
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*    mwenz - Bug 393113 - Auto-focus does not work for connections
+*    pjpaulin - Bug 352120 - Changed from a class to an interface - API BREAKAGE HERE
+*    pjpaulin - Bug 352120 - Renamed to IDiagramContainerUI so that DiagramEditor class can remain
+*    mwenz - Bug 407894 - Luna: After DiagramsInViews change graphical viewer is configured and initialized only by a workaround
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.EventObject;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramEditorInput.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramEditorInput.java
index ffbc15b..2e37fea 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramEditorInput.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IDiagramEditorInput.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.emf.common.util.URI;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IEclipseImageDescriptor.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IEclipseImageDescriptor.java
index 1debb73..16f8ca7 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IEclipseImageDescriptor.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/IEclipseImageDescriptor.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import org.eclipse.jface.resource.ImageDescriptor;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ResourceSetUpdateAdapter.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ResourceSetUpdateAdapter.java
index 67054f8..a0db0cb 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ResourceSetUpdateAdapter.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/editor/ResourceSetUpdateAdapter.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.editor;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractCopyFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractCopyFeature.java
index 3c874b4..16534af 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractCopyFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractCopyFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractDrillDownFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractDrillDownFeature.java
index 4e65df1..a540cd2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractDrillDownFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractDrillDownFeature.java
@@ -1,25 +1,22 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug  338067 - Drill down features should not use current diagram type provider
- *                          for opening diagram of other type
- *    Ali Akar, mwenz - Bug 340842 - Opening a user contributed editor
- *    Bug 336488 - DiagramEditor API
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug  338067 - Drill down features should not use current diagram type provider
+*                          for opening diagram of other type
+*    Ali Akar, mwenz - Bug 340842 - Opening a user contributed editor
+*    Bug 336488 - DiagramEditor API
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractPasteFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractPasteFeature.java
index b5d9509..97eeae9 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractPasteFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/AbstractPasteFeature.java
@@ -1,24 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 375533 - Problems with copy&paste in the tutorial
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 511287 - FileNotFoundException below AbstractPasteFeature.isResolvable
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 375533 - Problems with copy&paste in the tutorial
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 511287 - FileNotFoundException below AbstractPasteFeature.isResolvable
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import java.io.FileNotFoundException;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeature.java
index 382a12b..90b02b5 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeature.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 347421 - Make setDoneChanges accessible to sub classes
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 347421 - Make setDoneChanges accessible to sub classes
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import java.text.MessageFormat;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultFeatureProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultFeatureProvider.java
index 7fcd319..59c1581 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultFeatureProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultFeatureProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultPrintFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultPrintFeature.java
index d6f5a9b..bf6fcfa 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultPrintFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultPrintFeature.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import org.eclipse.draw2d.PrintFigureOperation;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultSaveImageFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultSaveImageFeature.java
index ab5bb68..ee6f03f 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultSaveImageFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/features/DefaultSaveImageFeature.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    mwenz - Bug 370888 - API Access to export and print
- *    mwenz - Bug 413139 - Visibility of convertImageToBytes in DefaultSaveImageFeature
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    mwenz - Bug 370888 - API Access to export and print
+*    mwenz - Bug 413139 - Visibility of convertImageToBytes in DefaultSaveImageFeature
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import java.io.FileOutputStream;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/GraphitiUIPlugin.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/GraphitiUIPlugin.java
index 90616d0..85679cd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/GraphitiUIPlugin.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/GraphitiUIPlugin.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import org.eclipse.ui.plugin.AbstractUIPlugin;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IDisposable.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IDisposable.java
index 361f072..e15fcc8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IDisposable.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IDisposable.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceManager.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceManager.java
index 8940d29..58c9df2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceManager.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceManager.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import org.eclipse.swt.graphics.Resource;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistry.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistry.java
index a32e83f..91ba807 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistry.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistry.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    palldredge - Bug 465675 - Improve SWT Font management 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    palldredge - Bug 465675 - Improve SWT Font management 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import org.eclipse.swt.graphics.Color;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistryHolder.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistryHolder.java
index c0e930a..af6c784 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistryHolder.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/IResourceRegistryHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/Messages.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/Messages.java
index 791f182..c9a4282 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/Messages.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/Messages.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2017 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import org.eclipse.osgi.util.NLS;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceManager.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceManager.java
index 3030c4b..8d69b84 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceManager.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceManager.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceRegistry.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceRegistry.java
index e670684..eee8668 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceRegistry.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/ResourceRegistry.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    palldredge - Bug 465675 - Improve SWT Font management 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    palldredge - Bug 465675 - Improve SWT Font management 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import java.util.HashMap;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/T.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/T.java
index f4da5d5..72fb38f 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/T.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/T.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal;
 
 import org.eclipse.graphiti.internal.util.AbstractTracer;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/AbstractPreDefinedAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/AbstractPreDefinedAction.java
index b1fcb6c..2c09178 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/AbstractPreDefinedAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/AbstractPreDefinedAction.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CopyAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CopyAction.java
index 4b579e7..82bc1ad 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CopyAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CopyAction.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.graphiti.features.ICopyFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CustomAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CustomAction.java
index addf344..10ee1dd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CustomAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/CustomAction.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.gef.commands.CommandStack;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/DeleteAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/DeleteAction.java
index e25809b..d8c409e 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/DeleteAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/DeleteAction.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.graphiti.features.IDeleteFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/FeatureExecutionHandler.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/FeatureExecutionHandler.java
index d4e3ad7..3fe76f9 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/FeatureExecutionHandler.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/FeatureExecutionHandler.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    fvelasco - Bug 323349 External feature invocation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    fvelasco - Bug 323349 External feature invocation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IAvailable.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IAvailable.java
index 29a977c..fb202cd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IAvailable.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IAvailable.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IContextAndFeatureProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IContextAndFeatureProvider.java
index 7c3b50e..dabb466 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IContextAndFeatureProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/IContextAndFeatureProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PasteAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PasteAction.java
index 1ac9732..e391158 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PasteAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PasteAction.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 339525 - Enrich paste context with location information
- *    mwenz - Bug 374701 - IPasteContext showing invalid location under certain circumstances
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 339525 - Enrich paste context with location information
+*    mwenz - Bug 374701 - IPasteContext showing invalid location under certain circumstances
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.draw2d.geometry.Point;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PrintGraphicalViewerAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PrintGraphicalViewerAction.java
index eb2e2e1..374fd74 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PrintGraphicalViewerAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/PrintGraphicalViewerAction.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 371527 - Recursive attempt to activate part while in the middle of activating part
- *    mwenz - Bug 370888 - API Access to export and print
- *    mwenz - Bug 449384 - PrintGraphicalViewerAction calculateEnabled() freezes Editor
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 371527 - Recursive attempt to activate part while in the middle of activating part
+*    mwenz - Bug 370888 - API Access to export and print
+*    mwenz - Bug 449384 - PrintGraphicalViewerAction calculateEnabled() freezes Editor
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.gef.GraphicalViewer;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/RemoveAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/RemoveAction.java
index 1d5bdb9..7d2d565 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/RemoveAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/RemoveAction.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    jpasch - Bug 323025 ActionBarContributor clean up
- *    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    jpasch - Bug 323025 ActionBarContributor clean up
+*    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/SaveImageAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/SaveImageAction.java
index a06b888..af71cda 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/SaveImageAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/SaveImageAction.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    jpasch - Bug 323025 ActionBarContributor cleanup
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    jpasch - Bug 323025 ActionBarContributor cleanup
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.core.runtime.IAdaptable;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/ToggleContextButtonPadAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/ToggleContextButtonPadAction.java
index f1aa4d9..8257391 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/ToggleContextButtonPadAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/ToggleContextButtonPadAction.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.graphiti.ui.editor.DiagramBehavior;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/UpdateAction.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/UpdateAction.java
index 5f2e477..7f19401 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/UpdateAction.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/action/UpdateAction.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    jpasch - Bug 323025 ActionBarContributor clean up
- *    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    jpasch - Bug 323025 ActionBarContributor clean up
+*    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.action;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AbstractCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AbstractCommand.java
index 84fbf12..e0e507c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AbstractCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AbstractCommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AddModelObjectCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AddModelObjectCommand.java
index 05eaefd..c124ff8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AddModelObjectCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/AddModelObjectCommand.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ContextEntryCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ContextEntryCommand.java
index 11f3803..9fe5481 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ContextEntryCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ContextEntryCommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.gef.commands.Command;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommand.java
index 42b0438..20a4957 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommand.java
@@ -1,30 +1,27 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 342874 CreateConnectionCommand overwriting "sourceLocation" with
- *            "targetLocation" on creation of a Connection
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mgorning - Bug 329517 - state call backs during creation of a connection
- *    Bug 336488 - DiagramEditor API
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    fvelasco - Bug 417577 - state call backs review
- *    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
- *    mwenz - Bug 424020 - Infinite loop when IConnectionCreateFeature returns true for the diagram
- *    mwenz - Bug 470455 - Difficulty in creating associations
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 342874 CreateConnectionCommand overwriting "sourceLocation" with
+*            "targetLocation" on creation of a Connection
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mgorning - Bug 329517 - state call backs during creation of a connection
+*    Bug 336488 - DiagramEditor API
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    fvelasco - Bug 417577 - state call backs review
+*    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
+*    mwenz - Bug 424020 - Infinite loop when IConnectionCreateFeature returns true for the diagram
+*    mwenz - Bug 470455 - Difficulty in creating associations
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateModelObjectCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateModelObjectCommand.java
index 309ec60..554590d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateModelObjectCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/CreateModelObjectCommand.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.graphiti.features.ICreateFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/EclipseProgress.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/EclipseProgress.java
index 15ff31c..cba23e3 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/EclipseProgress.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/EclipseProgress.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.core.runtime.IProgressMonitor;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GFCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GFCommand.java
index 8e01632..39cb211 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GFCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GFCommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GefCommandWrapper.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GefCommandWrapper.java
index df1558f..e0bb05c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GefCommandWrapper.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/GefCommandWrapper.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/MoveAnchorFeatureCommandWithContext.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/MoveAnchorFeatureCommandWithContext.java
index 3abdee0..be9e24f 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/MoveAnchorFeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/MoveAnchorFeatureCommandWithContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.gef.GraphicalEditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ReconnectCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ReconnectCommand.java
index fdb54a9..7547af8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ReconnectCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/command/ReconnectCommand.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import org.eclipse.draw2d.geometry.Point;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/AbstractConfigurationProviderHolder.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/AbstractConfigurationProviderHolder.java
index fbd00b0..4d6eb8b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/AbstractConfigurationProviderHolder.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/AbstractConfigurationProviderHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.config;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/ConfigurationProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/ConfigurationProvider.java
index db050ae..2d5e613 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/ConfigurationProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/ConfigurationProvider.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 466953 - NullPointerException in ConfigurationProvider.dispose
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 466953 - NullPointerException in ConfigurationProvider.dispose
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.config;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderHolder.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderHolder.java
index 18e1528..01000af 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderHolder.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.config;
 
 import org.eclipse.graphiti.ui.platform.IConfigurationProvider;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderInternal.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderInternal.java
index cf837fb..6f9762d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderInternal.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IConfigurationProviderInternal.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.config;
 
 import org.eclipse.graphiti.ui.internal.IResourceRegistryHolder;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IEditPartFactory.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IEditPartFactory.java
index 1af377b..fe84b6f 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IEditPartFactory.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/config/IEditPartFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.config;
 
 import org.eclipse.gef.EditPartFactory;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButton.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButton.java
index 39c706c..8b8219c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButton.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButton.java
@@ -1,25 +1,22 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *    mwenz - Bug 389379 - Editor Dirty Handling (gets broken after context button execution)
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    fvelasco - Bug 417577 - state call backs review
- *    apupier - Bug 508133 - Use FontRegistry for Tooltip
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*    mwenz - Bug 389379 - Editor Dirty Handling (gets broken after context button execution)
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    fvelasco - Bug 417577 - state call backs review
+*    apupier - Bug 508133 - Use FontRegistry for Tooltip
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.contextbuttons;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonManagerForPad.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonManagerForPad.java
index 78178c4..9892b7b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonManagerForPad.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonManagerForPad.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    Bug 336488 - DiagramEditor API
- *    mgorning - Bug 369370 - visibility of context button pad for graphical entities
- *    mwenz - Bug 392309 - Scrollbars appear when a tooltip is being displayed on a decorator
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    Bug 336488 - DiagramEditor API
+*    mgorning - Bug 369370 - visibility of context button pad for graphical entities
+*    mwenz - Bug 392309 - Scrollbars appear when a tooltip is being displayed on a decorator
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.contextbuttons;
 
 import java.util.HashMap;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonPad.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonPad.java
index d951d2f..73b9d09 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonPad.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ContextButtonPad.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    mwenz - Bug 397303 - Accessibility issue with Graphiti diagram in High Contrast Mode
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    apupier - Bug 508133 - Use FontRegistry for Tooltip
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    mwenz - Bug 397303 - Accessibility issue with Graphiti diagram in High Contrast Mode
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    apupier - Bug 508133 - Use FontRegistry for Tooltip
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.contextbuttons;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/IContextButtonManager.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/IContextButtonManager.java
index e7f5b2f..cc12ca5 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/IContextButtonManager.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/IContextButtonManager.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.contextbuttons;
 
 import org.eclipse.gef.GraphicalEditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ITransparencyProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ITransparencyProvider.java
index d6d5495..1400b81 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ITransparencyProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/contextbuttons/ITransparencyProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.contextbuttons;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/GFTemplateTransferDropTargetListener.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/GFTemplateTransferDropTargetListener.java
index ab6132a..234bf6f 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/GFTemplateTransferDropTargetListener.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/GFTemplateTransferDropTargetListener.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.dnd;
 
 import org.eclipse.gef.EditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/ObjectsTransferDropTargetListener.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/ObjectsTransferDropTargetListener.java
index f0049b1..9f98025 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/ObjectsTransferDropTargetListener.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/dnd/ObjectsTransferDropTargetListener.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Craig Petre - mwenz - Bug 378083 - Focus editor on DnD events from another control
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Craig Petre - mwenz - Bug 378083 - Focus editor on DnD events from another control
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.dnd;
 
 import org.eclipse.gef.EditPartViewer;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DefaultFlyoutPalettePreferences.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DefaultFlyoutPalettePreferences.java
index 0c19c9e..964fe37 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DefaultFlyoutPalettePreferences.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DefaultFlyoutPalettePreferences.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.draw2d.PositionConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramBehaviorDummy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramBehaviorDummy.java
index 4c56ce6..f9d8eaa 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramBehaviorDummy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramBehaviorDummy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramChangeListener.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramChangeListener.java
index d532867..ac9b7b3 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramChangeListener.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramChangeListener.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Enabled sub classes of Graphiti metamodel objects to trigger a refresh
- *    			(for Bug 330035 - Notational metamodel extension)
- *    Bug 336488 - DiagramEditor API
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 481936 - Fix NPE in DiagramChangeListener line 261 on move in Chess editor
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Enabled sub classes of Graphiti metamodel objects to trigger a refresh
+*    			(for Bug 330035 - Notational metamodel extension)
+*    Bug 336488 - DiagramEditor API
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 481936 - Fix NPE in DiagramChangeListener line 261 on move in Chess editor
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramEditorDummy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramEditorDummy.java
index 6f5933c..8bff5f7 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramEditorDummy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramEditorDummy.java
@@ -1,25 +1,22 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    mwenz - Bug 363539 - Enabled feature delegation via IDiagramEditor.execute method - contributed by Hernan
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
- *    mgorning - Bug 371671 - addGraphicalRepresentation returns null in dark mode
- *    pjpaulin - Bug 352120 - Added additional methods required by interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*    mwenz - Bug 363539 - Enabled feature delegation via IDiagramEditor.execute method - contributed by Hernan
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
+*    mgorning - Bug 371671 - addGraphicalRepresentation returns null in dark mode
+*    pjpaulin - Bug 352120 - Added additional methods required by interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.core.runtime.IProgressMonitor;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramRefreshJob.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramRefreshJob.java
index 98702aa..8ac64e1 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramRefreshJob.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DiagramRefreshJob.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 477659 - NullPointerException in DefaultRefreshBehavior.internalRefreshEditPart
- *    mwenz - Bug 494997 - EditPart does not refresh for active shapes inside inactive ContainerShapes
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 477659 - NullPointerException in DefaultRefreshBehavior.internalRefreshEditPart
+*    mwenz - Bug 494997 - EditPart does not refresh for active shapes inside inactive ContainerShapes
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.HashSet;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelChangeListener.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelChangeListener.java
index 67e4880..a1dc0ac 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelChangeListener.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelChangeListener.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340403 - Fixed NPE when adding graphical representations from 
- *                         a progress monitor job
- *    mwenz - Bug 352109 - Enable auto-update option for saved editor
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340403 - Fixed NPE when adding graphical representations from 
+*                         a progress monitor job
+*    mwenz - Bug 352109 - Enable auto-update option for saved editor
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.HashSet;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelWorkspaceSynchronizerDelegate.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelWorkspaceSynchronizerDelegate.java
index 5cf834a..8f5bfb1 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelWorkspaceSynchronizerDelegate.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/DomainModelWorkspaceSynchronizerDelegate.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.core.resources.IFile;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/EmfOnGefCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/EmfOnGefCommand.java
index 5a7a1d2..aa49baf 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/EmfOnGefCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/EmfOnGefCommand.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCommandStack.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCommandStack.java
index 83f2e57..72421f2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCommandStack.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCommandStack.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 351053 - Remove the need for WorkspaceCommandStackImpl
- *    mwenz - Bug 486902 - Cancelling model changes done in a CustomFeature logs an error stack trace
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 351053 - Remove the need for WorkspaceCommandStackImpl
+*    mwenz - Bug 486902 - Cancelling model changes done in a CustomFeature logs an error stack trace
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFConnectionCreationTool.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFConnectionCreationTool.java
index 6d2522e..c0789a7 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFConnectionCreationTool.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFConnectionCreationTool.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mgorning - Bug 329517 - state call backs during creation of a connection
- *    fvelasco - Bug 417577 - state call backs review
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mgorning - Bug 329517 - state call backs during creation of a connection
+*    fvelasco - Bug 417577 - state call backs review
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCreationTool.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCreationTool.java
index 3db4e42..d0b05de 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCreationTool.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFCreationTool.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.core.runtime.IStatus;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFDragConnectionTool.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFDragConnectionTool.java
index b1abac1..6ad69c0 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFDragConnectionTool.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFDragConnectionTool.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    fvelasco - Bug 417577 - state call backs review
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    fvelasco - Bug 417577 - state call backs review
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFFigureCanvas.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFFigureCanvas.java
index eaa0fe5..376b729 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFFigureCanvas.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFFigureCanvas.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.beans.PropertyChangeEvent;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeDragTracker.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeDragTracker.java
index c405a60..1bee02a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeDragTracker.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeDragTracker.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.gef.DragTracker;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeSelectionTool.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeSelectionTool.java
index fb6764e..8837c13 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeSelectionTool.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeSelectionTool.java
@@ -1,18 +1,19 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2011 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
- *     		changed calculateNewSelection to correctly handle HandleBounds
- *     Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
- *                                          the same way as for BoxRelativeAnchors
- *     
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
+*     		changed calculateNewSelection to correctly handle HandleBounds
+*     Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
+*                                          the same way as for BoxRelativeAnchors
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 import java.util.ArrayList;
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeToolEntry.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeToolEntry.java
index 30d6cca..d0dfb54 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeToolEntry.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFMarqueeToolEntry.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.gef.SharedImages;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFOnEmfCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFOnEmfCommand.java
index 48b986a..8ea4544 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFOnEmfCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFOnEmfCommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.emf.common.command.Command;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRoot.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRoot.java
index 871c2f9..d74f298 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRoot.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRoot.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *    Bug 336488 - DiagramEditor API
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    mwenz - Bug 428068 - Automatically unselect a tool entry in palette like 'connection creation' after execution
- *    mwenz - Bug 467476 - NullPointerException in GFPaletteRoot.createModelIndependentTools
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*    Bug 336488 - DiagramEditor API
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    mwenz - Bug 428068 - Automatically unselect a tool entry in palette like 'connection creation' after execution
+*    mwenz - Bug 467476 - NullPointerException in GFPaletteRoot.createModelIndependentTools
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPanningSelectionToolEntry.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPanningSelectionToolEntry.java
index 0c8dbe6..d76c00a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPanningSelectionToolEntry.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFPanningSelectionToolEntry.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
- *    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
+*    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.gef.palette.PanningSelectionToolEntry;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFScrollingGraphicalViewer.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFScrollingGraphicalViewer.java
index ce0470b..d2fc713 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFScrollingGraphicalViewer.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFScrollingGraphicalViewer.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFWorkspaceCommandStackImpl.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFWorkspaceCommandStackImpl.java
index 978f3d4..e91ae31 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFWorkspaceCommandStackImpl.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GFWorkspaceCommandStackImpl.java
@@ -1,30 +1,27 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 351053 - Remove the need for WorkspaceCommandStackImpl
- *    mwenz - Bug 371717 - IllegalStateException When updating cells on Diagram
- *    mwenz - Bug 389380 - Undo/Redo handling wrong Command executed by undo action
- *    mwenz - Bug 430609 - Re-entrance in diagram update causes transaction error
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 464596 - BasicIndexOutOfBoundsException in BasicEList.get
- *    Laurent Le Moux - mwenz - Bug 475240 - Malfunctioning redo GFWorkspaceCommandStackImpl
- *    mwenz - Bug 477083 - Read-write transaction not created if another thread is using runExclusive()
- *    mwenz - Bug 481994 - canUndo/canRedo called twice
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 351053 - Remove the need for WorkspaceCommandStackImpl
+*    mwenz - Bug 371717 - IllegalStateException When updating cells on Diagram
+*    mwenz - Bug 389380 - Undo/Redo handling wrong Command executed by undo action
+*    mwenz - Bug 430609 - Re-entrance in diagram update causes transaction error
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 464596 - BasicIndexOutOfBoundsException in BasicEList.get
+*    Laurent Le Moux - mwenz - Bug 475240 - Malfunctioning redo GFWorkspaceCommandStackImpl
+*    mwenz - Bug 477083 - Read-write transaction not created if another thread is using runExclusive()
+*    mwenz - Bug 481994 - canUndo/canRedo called twice
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.Map;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GefOnEmfCommand.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GefOnEmfCommand.java
index 782a7f8..0d54726 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GefOnEmfCommand.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GefOnEmfCommand.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.gef.commands.Command;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GraphitiScrollingGraphicalViewer.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GraphitiScrollingGraphicalViewer.java
index 6cc7e0d..b15d6b3 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GraphitiScrollingGraphicalViewer.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/GraphitiScrollingGraphicalViewer.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2019 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    fvelasco - Bug 323356 - Mouse-wheel support for scrolling and zooming
- *    Hubert Guerard, mwenz - Bug 543847 - Add capability to select several PictogramElement from a selection of PictogramElement
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    fvelasco - Bug 323356 - Mouse-wheel support for scrolling and zooming
+*    Hubert Guerard, mwenz - Bug 543847 - Add capability to select several PictogramElement from a selection of PictogramElement
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/RefreshPerformanceCache.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/RefreshPerformanceCache.java
index c1ab2cf..6b09d64 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/RefreshPerformanceCache.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/RefreshPerformanceCache.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import java.util.HashSet;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/ThumbNailView.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/ThumbNailView.java
index d3deca6..461c989 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/ThumbNailView.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/editor/ThumbNailView.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 502091 - NPE in GFDirectEditManager.bringDown
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 502091 - NPE in GFDirectEditManager.bringDown
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import org.eclipse.draw2d.Figure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/feature/DebugFeature.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/feature/DebugFeature.java
index 76a505b..689deff 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/feature/DebugFeature.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/feature/DebugFeature.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    cbrand - Bug 377783 - Dump for figures in connection layer needed
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    cbrand - Bug 377783 - Dump for figures in connection layer needed
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.feature;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/BezierPoint.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/BezierPoint.java
index 5ca7634..d8fbd7d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/BezierPoint.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/BezierPoint.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.geometry.Point;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/DecoratorImageFigure.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/DecoratorImageFigure.java
index 968dfa4..27e94ec 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/DecoratorImageFigure.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/DecoratorImageFigure.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.swt.graphics.Image;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/FlexibleRotatableLocator.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/FlexibleRotatableLocator.java
index 9bb2ca4..1821c9a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/FlexibleRotatableLocator.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/FlexibleRotatableLocator.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.AbstractLocator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractPointListShape.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractPointListShape.java
index 1ba8017..5006de2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractPointListShape.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractPointListShape.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Connection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractRotatableDecoration.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractRotatableDecoration.java
index 4228df2..1fb3ed2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractRotatableDecoration.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractRotatableDecoration.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *    cbrand - Bug 369371 - ConnectionDecorator visualization cut
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*    cbrand - Bug 369371 - ConnectionDecorator visualization cut
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractShape.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractShape.java
index ea41f65..adf4d6e 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractShape.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFAbstractShape.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
- *    cbrand - Bug 370440 - Over scaling of connections and lines after canvas zoom
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *    mwenz - Bug 434436 - Highlighting of Anchors on hover does not seem to work
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
+*    cbrand - Bug 370440 - Over scaling of connections and lines after canvas zoom
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*    mwenz - Bug 434436 - Highlighting of Anchors on hover does not seem to work
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import java.util.Iterator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipse.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipse.java
index cd8b34d..ae78310 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipse.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipse.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipseDecoration.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipseDecoration.java
index 3666d3a..ddd4c0b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipseDecoration.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFEllipseDecoration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtil.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtil.java
index 033a71f..d666c08 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtil.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtil.java
@@ -1,19 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 416039 - TextStyle rendering does not fall back to abstract text font
- *    palldredge - Bug 504173 - Selection Issues with Large Connections
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 416039 - TextStyle rendering does not fall back to abstract text font
+*    palldredge - Bug 504173 - Selection Issues with Large Connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFlowPage.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFlowPage.java
index 1844f35..f129354 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFlowPage.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFFlowPage.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.PositionConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFImageFigure.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFImageFigure.java
index b0baafd..c9b4e32 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFImageFigure.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFImageFigure.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Veit Hoffmann (mwenz) - Bug 342869 - Image doesn't scale the contained SWT Image on resize
- *    mwenz - Bug 464857 - Images created by GFImageFigure are not destroyed
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Veit Hoffmann (mwenz) - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*    mwenz - Bug 464857 - Images created by GFImageFigure are not destroyed
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFMultilineText.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFMultilineText.java
index 5406966..d952052 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFMultilineText.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFMultilineText.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 347144 - Angle of MultiText objects can't be modified
- *    mgorning - Bug 377419 - Hide text in underlying GA while DirectEditing is enabled
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 347144 - Angle of MultiText objects can't be modified
+*    mgorning - Bug 377419 - Hide text in underlying GA while DirectEditing is enabled
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Figure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygon.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygon.java
index d68949e..592ba87 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygon.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygon.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygonDecoration.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygonDecoration.java
index ee396eb..3d6dfdc 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygonDecoration.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolygonDecoration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.RotatableDecoration;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolyline.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolyline.java
index 55d04e7..48a8b3b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolyline.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolyline.java
@@ -1,24 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *    mwenz - Bug 363796 - Make setting of selection width of connections public
- *    mwenz - Bug 497669 - IndexOutOfBoundsException below GFPolyline.createPath (thrown in ArrayList.rangeCheck)
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 14.10.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*    mwenz - Bug 363796 - Make setting of selection width of connections public
+*    mwenz - Bug 497669 - IndexOutOfBoundsException below GFPolyline.createPath (thrown in ArrayList.rangeCheck)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineConnection.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineConnection.java
index d83574c..70f4cd2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineConnection.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineConnection.java
@@ -1,24 +1,25 @@
-/*******************************************************************************
- * Copyright (c) 2000, 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
- *     		added getBounds
- *     		added getSourceDecorations
- *     		added getTargetDecorations
- *     		added setSourceDecorations
- *     		added setTargetDecorations
- *     		removed getMaxValue
- *     		added override tags
- *     mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *     mgorning - Bug 378301 - Small gap between connections and right side anchor
- *     
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2000, 2019 IBM Corporation and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*     IBM Corporation - initial API and implementation
+*     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
+*     		added getBounds
+*     		added getSourceDecorations
+*     		added getTargetDecorations
+*     		added setSourceDecorations
+*     		added setTargetDecorations
+*     		removed getMaxValue
+*     		added override tags
+*     mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*     mgorning - Bug 378301 - Small gap between connections and right side anchor
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineDecoration.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineDecoration.java
index 4b3e6e9..fa8d6ee 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineDecoration.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFPolylineDecoration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.RotatableDecoration;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRectangleFigure.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRectangleFigure.java
index 9c80a57..914b6aa 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRectangleFigure.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRectangleFigure.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRoundedRectangle.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRoundedRectangle.java
index 8377c23..32d86ec 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRoundedRectangle.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFRoundedRectangle.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFText.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFText.java
index e1fc262..e4b1a3e 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFText.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFText.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 365536 - Using BoxRelativeAnchor with relativeWidth = 1 display ellipsis in related Text
- *    mgorning - Bug 374190 - Vertically aligned text disappears after the height of TextImpl is increased
- *    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems
- *    mwenz - Bug 405920 - Text background color is ignored on rotated text
- *    mwenz - Bug 423573 - Angles should never be integer
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 365536 - Using BoxRelativeAnchor with relativeWidth = 1 display ellipsis in related Text
+*    mgorning - Bug 374190 - Vertically aligned text disappears after the height of TextImpl is increased
+*    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems
+*    mwenz - Bug 405920 - Text background color is ignored on rotated text
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFTextFlow.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFTextFlow.java
index 348a058..6cb8c30 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFTextFlow.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/GFTextFlow.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 347144 - Angle of MultiText objects can't be modified
- *    mgorning - Bug 377419 - Hide text in underlying GA while DirectEditing is enabled
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 347144 - Angle of MultiText objects can't be modified
+*    mgorning - Bug 377419 - Hide text in underlying GA while DirectEditing is enabled
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/ImageFigureAntialias.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/ImageFigureAntialias.java
index 12ec0ce..f1b5db8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/ImageFigureAntialias.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/ImageFigureAntialias.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformLayeredPane.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformLayeredPane.java
index eec97a9..5dc5e52 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformLayeredPane.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformLayeredPane.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *    mwenz - Bug 477421 - SWTException in ScaledGraphics.getCachedFontData
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*    mwenz - Bug 477421 - SWTException in ScaledGraphics.getCachedFontData
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.fixed;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformRootEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformRootEditPart.java
index 3450f31..1c5e142 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformRootEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableFreeformRootEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.fixed;
 
 import org.eclipse.draw2d.FreeformLayer;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableRootEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableRootEditPart.java
index 8cbc82c..75b34e2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableRootEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScalableRootEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.fixed;
 
 import org.eclipse.draw2d.FreeformLayer;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScaledGraphics.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScaledGraphics.java
index de71a89..17a65dd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScaledGraphics.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScaledGraphics.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 477421 - SWTException in ScaledGraphics.getCachedFontData
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 477421 - SWTException in ScaledGraphics.getCachedFontData
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.fixed;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScrollableThumbnail.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScrollableThumbnail.java
index f2930b2..b47170d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScrollableThumbnail.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedScrollableThumbnail.java
@@ -1,17 +1,19 @@
-/*******************************************************************************
- * 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
- *     		changed mouseDragged to check for existing startLocation
- *     		changed deactivate to handle subsequent calls
- *     		added override tags
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2000, 2019 IBM Corporation and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*     IBM Corporation - initial API and implementation
+*     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
+*     		changed mouseDragged to check for existing startLocation
+*     		changed deactivate to handle subsequent calls
+*     		added override tags
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.fixed;
 
 import java.beans.PropertyChangeEvent;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedThumbnail.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedThumbnail.java
index f805f31..a026dbc 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedThumbnail.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/fixed/FixedThumbnail.java
@@ -1,17 +1,19 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
- * 			Used ScaledGraphics instead of Graphics for thumbnail
- * 			Changed method run to handle the complete rectangle instead of tiles
- * 			Changed resetThumbnailImage to dispose if not empty
- ******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2000, 2019 IBM Corporation and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*     IBM Corporation - initial API and implementation
+*     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
+* 			Used ScaledGraphics instead of Graphics for thumbnail
+* 			Changed method run to handle the complete rectangle instead of tiles
+* 			Changed resetThumbnailImage to dispose if not empty
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.fixed;
 
 import java.util.Iterator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/messages.properties b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/messages.properties
index fa05b97..81fa8e8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/messages.properties
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/messages.properties
@@ -1,23 +1,20 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2017 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Bug 327669 - removed dependencies to GEF internal stuff
 #    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc
 #    jpasch - Bug 323025 ActionBarContributor cleanup
 #    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
 #    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 AbstractFigureSelectionDialog_0_xtxt=Select picture options
 AbstractFigureSelectionDialog_1_xtxt=Figure
 AbstractFigureSelectionDialog_2_xbut=&All
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/partfactory/PictogramsEditPartFactory.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/partfactory/PictogramsEditPartFactory.java
index 44f4dce..b9341db 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/partfactory/PictogramsEditPartFactory.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/partfactory/PictogramsEditPartFactory.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
- *                                         the same way as for BoxRelativeAnchors
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
+*                                         the same way as for BoxRelativeAnchors
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.partfactory;
 
 import java.util.Map;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AdvancedAnchorEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AdvancedAnchorEditPart.java
index 8dd463a..5d80433 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AdvancedAnchorEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AdvancedAnchorEditPart.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
- *                                         the same way as for BoxRelativeAnchors
- *    fvelasco - Bug 417577 - state call backs review
- *    mwenz - Bug 434436 - Highlighting of Anchors on hover does not seem to work
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
+*                                         the same way as for BoxRelativeAnchors
+*    fvelasco - Bug 417577 - state call backs review
+*    mwenz - Bug 434436 - Highlighting of Anchors on hover does not seem to work
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AnchorContainerDelegate.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AnchorContainerDelegate.java
index 74a67ed..d3b73d6 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AnchorContainerDelegate.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/AnchorContainerDelegate.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CompositeConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CompositeConnectionEditPart.java
index c1b8528..da0fbf3 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CompositeConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CompositeConnectionEditPart.java
@@ -1,17 +1,15 @@
-/**
- * <copyright>
- * 
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    Benjamin Schmeling - initial API, implementation and documentation for Bug 367483
- * 
- * </copyright>
- */
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Benjamin Schmeling - initial API, implementation and documentation for Bug 367483
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionDecoratorEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionDecoratorEditPart.java
index 387027d..3be1f20 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionDecoratorEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionDecoratorEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import org.eclipse.graphiti.mm.pictograms.Shape;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionEditPart.java
index e9381d6..1d3b743 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ConnectionEditPart.java
@@ -1,25 +1,22 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG 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:
- *    SAP AG - initial API, implementation and documentation
- *    Torkild U. Resheim - Allow double-click handling, bug 340708
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 341898 - Support for AdvancedPropertySheet
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    Hallvard Traetteberg - Félix Velasco - Bug 403272 - Set the location of DoubleClickContext for DoubleClickFeature
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Torkild U. Resheim - Allow double-click handling, bug 340708
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 341898 - Support for AdvancedPropertySheet
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    Hallvard Traetteberg - Félix Velasco - Bug 403272 - Set the location of DoubleClickContext for DoubleClickFeature
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ContainerShapeEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ContainerShapeEditPart.java
index aeb1881..3d354b5 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ContainerShapeEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ContainerShapeEditPart.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 379836 - StackOverflow when parent GA is the root GA of an inactive shape
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 379836 - StackOverflow when parent GA is the root GA of an inactive shape
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CurvedConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CurvedConnectionEditPart.java
index 0bd7c7d..31dc3e6 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CurvedConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/CurvedConnectionEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2012 SAP AG.
- * 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:
- *    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz Bug 352119 - initial API, implementation and documentation contributed by Benjamin Schmeling
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/DiagramEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/DiagramEditPart.java
index 7aabbc5..63d12f7 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/DiagramEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/DiagramEditPart.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 470455 - Difficulty in creating associations
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 470455 - Difficulty in creating associations
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/FreeFormConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/FreeFormConnectionEditPart.java
index 92b483f..3e5f260 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/FreeFormConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/FreeFormConnectionEditPart.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/GFAdapter.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/GFAdapter.java
index d7f8d91..05e668d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/GFAdapter.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/GFAdapter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerDelegate.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerDelegate.java
index 83c34fc..33563b3 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerDelegate.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerDelegate.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerEditPart.java
index 5b32ddb..75d74af 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorContainerEditPart.java
@@ -1,25 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 09.03.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorEditPart.java
index 0842e05..f9aa602 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IAnchorEditPart.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 05.04.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IBoxRelativeAnchorEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IBoxRelativeAnchorEditPart.java
index a5c56f2..adbcf10 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IBoxRelativeAnchorEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IBoxRelativeAnchorEditPart.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 05.04.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionDecoratorEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionDecoratorEditPart.java
index 2f7fbd9..b5d79a6 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionDecoratorEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionDecoratorEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionEditPart.java
index 98f6dce..cf24006 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IConnectionEditPart.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 09.03.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IContainerShapeEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IContainerShapeEditPart.java
index cf79242..64fc2bf 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IContainerShapeEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IContainerShapeEditPart.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 14.03.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IDiagramEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IDiagramEditPart.java
index 93d2512..b0cf7ca 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IDiagramEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IDiagramEditPart.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 14.03.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IFixPointAnchorEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IFixPointAnchorEditPart.java
index b8e8b6c..8c7d247 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IFixPointAnchorEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IFixPointAnchorEditPart.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 05.04.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IGFAdapter.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IGFAdapter.java
index 70985d7..5420eed 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IGFAdapter.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IGFAdapter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementDelegate.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementDelegate.java
index 1b5de81..73764ff 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementDelegate.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementDelegate.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementEditPart.java
index 4a0c4de..836e826 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IPictogramElementEditPart.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IShapeEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IShapeEditPart.java
index 57a9bf8..b24fab4 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IShapeEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/IShapeEditPart.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import org.eclipse.gef.EditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ManhattanConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ManhattanConnectionEditPart.java
index 23959d7..1660eb9 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ManhattanConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ManhattanConnectionEditPart.java
@@ -1,25 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 27.09.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/PictogramElementDelegate.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/PictogramElementDelegate.java
index ae325b6..161ae17 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/PictogramElementDelegate.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/PictogramElementDelegate.java
@@ -1,38 +1,36 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2017 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 348662 - Setting tooptip to null in tool behavior provider doesn't clear up
- *                         tooltip if the associated figure has a previous tooltip
- *    mgorning - Bug 363229 - Nested GA inside Anchors are not correctly refreshed
- *    Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
- *                                         the same way as for BoxRelativeAnchors
- *    mgorning - Bug 347144 - Angle of MultiText objects can't be modified
- *    Felix Velasco (mgorning) - Bug 328279 - Support rendering decorator positioning for connection text decorator
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 341898 - Support for AdvancedPropertySheet
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems 
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    Andreas Graf/mwenz - Bug 396793 - Text decorators
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 412858 - canUpdate is not consulted before calling updateNeeded during startup
- *    mwenz - Bug 434458 - Connections don't support Color decorators
- *    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
- *    mwenz - Bug 464857 - Images created by GFImageFigure are not destroyed
- *    mwenz - Bug 481619 - Graphiti is not using custom PlatformGraphicsAlgorithm's layout manager; enforces XYLayout
- *    palldredge - Bug 465675 - Improve SWT Font management 
- *    mwenz - Bug 522699 - NullPointerException in GefService.getConnectionPointAt
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 348662 - Setting tooptip to null in tool behavior provider doesn't clear up
+*                         tooltip if the associated figure has a previous tooltip
+*    mgorning - Bug 363229 - Nested GA inside Anchors are not correctly refreshed
+*    Felix Velasco (mwenz) - Bug 349416 - Support drag&drop operations on FixPointAnchors
+*                                         the same way as for BoxRelativeAnchors
+*    mgorning - Bug 347144 - Angle of MultiText objects can't be modified
+*    Felix Velasco (mgorning) - Bug 328279 - Support rendering decorator positioning for connection text decorator
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 341898 - Support for AdvancedPropertySheet
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems 
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    Andreas Graf/mwenz - Bug 396793 - Text decorators
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 412858 - canUpdate is not consulted before calling updateNeeded during startup
+*    mwenz - Bug 434458 - Connections don't support Color decorators
+*    mwenz - Bug 459386 - Refresh Connection when getDiagramBehavior().refreshRenderingDecorators(PEInstance) is called
+*    mwenz - Bug 464857 - Images created by GFImageFigure are not destroyed
+*    mwenz - Bug 481619 - Graphiti is not using custom PlatformGraphicsAlgorithm's layout manager; enforces XYLayout
+*    palldredge - Bug 465675 - Improve SWT Font management 
+*    mwenz - Bug 522699 - NullPointerException in GefService.getConnectionPointAt
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ShapeEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ShapeEditPart.java
index b3df2b2..b61e6c2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ShapeEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/ShapeEditPart.java
@@ -1,28 +1,25 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 327756 - Cancelled double click feature marked editor dirty
- *    Bug 336488 - DiagramEditor API
- *    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
- *    mwenz - Bug 341898 - Support for AdvancedPropertySheet
- *    mgorning - Bug 386913 - Support also Single-Click-Features
- *    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    Hallvard Traetteberg - Félix Velasco - Bug 403272 - Set the location of DoubleClickContext for DoubleClickFeature
- *    mwenz - Bug 425750 - getSelection not working
- *    mwenz - Bug 475133 - NullPointerException in ShapeEditPart.createEditPolicies
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 327756 - Cancelled double click feature marked editor dirty
+*    Bug 336488 - DiagramEditor API
+*    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
+*    mwenz - Bug 341898 - Support for AdvancedPropertySheet
+*    mgorning - Bug 386913 - Support also Single-Click-Features
+*    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    Hallvard Traetteberg - Félix Velasco - Bug 403272 - Set the location of DoubleClickContext for DoubleClickFeature
+*    mwenz - Bug 425750 - getSelection not working
+*    mwenz - Bug 475133 - NullPointerException in ShapeEditPart.createEditPolicies
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposal.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposal.java
index b20df83..9b6f0ab 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposal.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposal.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.graphiti.func.IProposal;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalListener.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalListener.java
index fdeeba5..1b7efc9 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalListener.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalListener.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.graphiti.func.IProposal;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalProvider.java
index 59cdadd..0ba4c25 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/ContentProposalProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.graphiti.features.IDirectEditingFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFCellEditorValidator.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFCellEditorValidator.java
index ec01c78..8b7f8f5 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFCellEditorValidator.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFCellEditorValidator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.graphiti.features.IDirectEditingFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFDirectEditManager.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFDirectEditManager.java
index a690c31..d5be43a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFDirectEditManager.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/GFDirectEditManager.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
- *    mgorning - Bug 377419 - Hide text in underlying GA while DirectEditing is enabled
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 492362 - Error when calling Help (F1) while direct edit is active
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
+*    mgorning - Bug 377419 - Hide text in underlying GA while DirectEditing is enabled
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 492362 - Error when calling Help (F1) while direct edit is active
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/IDirectEditHolder.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/IDirectEditHolder.java
index 75913df..b6bbf77 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/IDirectEditHolder.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/IDirectEditHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.graphiti.features.IDirectEditingFeature;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellEditor.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellEditor.java
index 93c37d5..2523f53 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellEditor.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellEditor.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.graphiti.func.IProposal;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellLocator.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellLocator.java
index 506a262..212941a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellLocator.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/parts/directedit/TextCellLocator.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
- *    mwenz - Bug 359112 - Connection text decorator's direct editing box size is not accurate when the text has length zero
- *    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
+*    mwenz - Bug 359112 - Connection text decorator's direct editing box size is not accurate when the text has length zero
+*    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.parts.directedit;
 
 import org.eclipse.draw2d.FigureUtilities;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/DiagramTypeImpl.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/DiagramTypeImpl.java
index 396dbc9..aa30fb6 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/DiagramTypeImpl.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/DiagramTypeImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.platform;
 
 import org.eclipse.graphiti.dt.IDiagramType;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/ExtensionManager.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/ExtensionManager.java
index c8273b2..c121a16 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/ExtensionManager.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/platform/ExtensionManager.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352709 - invalid image provider id crashes diagram editor
- *    fvelasco - Bug 323349 - Enable external invocation of features
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352709 - invalid image provider id crashes diagram editor
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.platform;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/BendpointEditPolicyFixed.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/BendpointEditPolicyFixed.java
index 5654890..2b8c5bb 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/BendpointEditPolicyFixed.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/BendpointEditPolicyFixed.java
@@ -1,27 +1,30 @@
-/*******************************************************************************
- * Copyright (c) 2000, 2005 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
- *     		made fields NULL_CONSTRAINT, originalConstraint, isDeleting, ref1, ref2 protected
- *     		made methods protected:
- *     			createHandlesForAutomaticBendpoints
- *     			createHandlesForUserBendpoints
- *     			isAutomaticallyBending
- *     			lineContainsPoint
- *     			setReferencePoints
- *     		added
- *     			getConfigurationProvider
- *     			getFeatureProvider
- *     			setConfigurationProvider
- *     			checkMoveAndRemoveBendpointFeature
- *     			checkCreateBendpointFeature 
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2000, 2019 IBM Corporation and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*     IBM Corporation - initial API and implementation
+*     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
+*     		made fields NULL_CONSTRAINT, originalConstraint, isDeleting, ref1, ref2 protected
+*     		made methods protected:
+*     			createHandlesForAutomaticBendpoints
+*     			createHandlesForUserBendpoints
+*     			isAutomaticallyBending
+*     			lineContainsPoint
+*     			setReferencePoints
+*     		added
+*     			getConfigurationProvider
+*     			getFeatureProvider
+*     			setConfigurationProvider
+*     			checkMoveAndRemoveBendpointFeature
+*     			checkCreateBendpointFeature 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
+
 // ****************************************************************************
 // ****************************************************************************
 //           THIS CLASS IS MOSTLY COPIED FROM BendpointEditPolicy
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionBendpointEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionBendpointEditPolicy.java
index 2869704..951f24b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionBendpointEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionBendpointEditPolicy.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionHighlightEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionHighlightEditPolicy.java
index 5a04fbf..c418bcf 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionHighlightEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ConnectionHighlightEditPolicy.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mlypik - Bug 401792 - Disable starting reconnection
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mlypik - Bug 401792 - Disable starting reconnection
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultConnectionEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultConnectionEditPolicy.java
index 5484405..7e80a1f 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultConnectionEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultConnectionEditPolicy.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG, Redhat.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Aurelien Pupier - Bug 499720 - DefaultConnectionEditPolicy doesn't support scroll
- *    mwenz - Bug 541020 - IndexOutOfBoundsException below DefaultConnectionEditPolicy.getAddCommand
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Aurelien Pupier - Bug 499720 - DefaultConnectionEditPolicy doesn't support scroll
+*    mwenz - Bug 541020 - IndexOutOfBoundsException below DefaultConnectionEditPolicy.getAddCommand
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultDirectEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultDirectEditPolicy.java
index 5af98da..5dd8592 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultDirectEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultDirectEditPolicy.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2017 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
- *    mwenz - Bug 397346 - Digram Editor loses focus on closing of MessageDialog in Graphiti 
- *    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
+*    mwenz - Bug 397346 - Digram Editor loses focus on closing of MessageDialog in Graphiti 
+*    pjpaulin - Bug 352120 - Eliminated assumption that diagram is in an IEditorPart
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultEditPolicyFactory.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultEditPolicyFactory.java
index 36bd2b8..7c2883a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultEditPolicyFactory.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/DefaultEditPolicyFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.gef.EditPolicy;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFConnectionEndpointTracker.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFConnectionEndpointTracker.java
index 2e44bf7..e4edc67 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFConnectionEndpointTracker.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFConnectionEndpointTracker.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.gef.ConnectionEditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFEditPolicyDelegate.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFEditPolicyDelegate.java
index 393b1b6..52b26d4 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFEditPolicyDelegate.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFEditPolicyDelegate.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFNodeEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFNodeEditPolicy.java
index b117ce4..52fd1d2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFNodeEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFNodeEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFResizableEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFResizableEditPolicy.java
index eca4c00..a4eedbf 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFResizableEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/GFResizableEditPolicy.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    jpasch - BUG 341180: Graphiti fails to handle resize after custom feature addition in the tutorial
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *    mwenz - Bug 346487 - No selection feedback for non-resizable diagram nodes
- *    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    jpasch - BUG 341180: Graphiti fails to handle resize after custom feature addition in the tutorial
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*    mwenz - Bug 346487 - No selection feedback for non-resizable diagram nodes
+*    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/IEditPolicyFactory.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/IEditPolicyFactory.java
index 66bf807..8d49d2c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/IEditPolicyFactory.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/IEditPolicyFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.gef.EditPolicy;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ModelObjectDeleteEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ModelObjectDeleteEditPolicy.java
index 5e1506a..52f7389 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ModelObjectDeleteEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ModelObjectDeleteEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.gef.EditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ResourceManagingGraphicalEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ResourceManagingGraphicalEditPolicy.java
index a5149f4..705a2f8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ResourceManagingGraphicalEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ResourceManagingGraphicalEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeContainerAndXYLayoutEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeContainerAndXYLayoutEditPolicy.java
index ea70f2b..c6d160e 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeContainerAndXYLayoutEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeContainerAndXYLayoutEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.gef.EditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeForbidLayoutEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeForbidLayoutEditPolicy.java
index 9330cef..1da1a79 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeForbidLayoutEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeForbidLayoutEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.gef.EditPart;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHighlightEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHighlightEditPolicy.java
index 652a226..efd0446 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHighlightEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHighlightEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHoverEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHoverEditPolicy.java
index debf0c7..e27b8f4 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHoverEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeHoverEditPolicy.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeXYLayoutEditPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeXYLayoutEditPolicy.java
index 480fdb7..3f394c7 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeXYLayoutEditPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/ShapeXYLayoutEditPolicy.java
@@ -1,28 +1,25 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2017 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    jpasch - BUG 341180: Graphiti fails to handle resize after custom feature addition in the tutorial
- *    mwenz - Bug 346067: Current Milestone Build does no longer build against Eclipse 3.6
- *    mwenz - Bug 355027: Move of connection decorators when zoom level != 100 behaves weird
- *    mgorning - Bug 342262 - enhanced resize behavior for container shapes
- *    Bug 336488 - DiagramEditor API
- *    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
- *    mgorning - Bug 383512 - Moving (Resizing) Problem - Polyline/Polygon on first level
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 496822 - NullPointerException in ShapeXYLayoutEditPolicy.getMoveConnectionDecoratorCommand
- *    mwenz - Bug 528405 - ArithmeticException in ShapeXYLayoutEditPolicy.getSnapValue
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    jpasch - BUG 341180: Graphiti fails to handle resize after custom feature addition in the tutorial
+*    mwenz - Bug 346067: Current Milestone Build does no longer build against Eclipse 3.6
+*    mwenz - Bug 355027: Move of connection decorators when zoom level != 100 behaves weird
+*    mgorning - Bug 342262 - enhanced resize behavior for container shapes
+*    Bug 336488 - DiagramEditor API
+*    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
+*    mgorning - Bug 383512 - Moving (Resizing) Problem - Polyline/Polygon on first level
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 496822 - NullPointerException in ShapeXYLayoutEditPolicy.getMoveConnectionDecoratorCommand
+*    mwenz - Bug 528405 - ArithmeticException in ShapeXYLayoutEditPolicy.getSnapValue
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.policy;
 
 import java.util.Arrays;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/ContextButtonDragRequest.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/ContextButtonDragRequest.java
index 3ad82f6..68e50bc 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/ContextButtonDragRequest.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/ContextButtonDragRequest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.requests;
 
 import org.eclipse.gef.requests.CreateConnectionRequest;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/GFDirectEditRequest.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/GFDirectEditRequest.java
index 991be81..43d5d01 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/GFDirectEditRequest.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/requests/GFDirectEditRequest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.requests;
 
 import org.eclipse.graphiti.ui.internal.parts.directedit.IDirectEditHolder;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/GraphitiUiInternal.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/GraphitiUiInternal.java
index f048dec..4f58c6e 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/GraphitiUiInternal.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/GraphitiUiInternal.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services;
 
 import org.eclipse.graphiti.ui.internal.services.impl.CommandService;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ICommandService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ICommandService.java
index 781d92a..5fc3848 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ICommandService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ICommandService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    mwenz - Bug 324859 - initial API, implementation and documentation
- *    mwenz - Bug 389380 - Undo/Redo handling wrong Command executed by undo action
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 324859 - initial API, implementation and documentation
+*    mwenz - Bug 389380 - Undo/Redo handling wrong Command executed by undo action
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services;
 
 import org.eclipse.graphiti.IExecutionInfo;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IEmfService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IEmfService.java
index 7d7c9bb..3f3e704 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IEmfService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IEmfService.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    Bug 336488 - DiagramEditor API
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *    mwenz - Bug 393074 - Save Editor Progress Monitor Argument
- *    fvelasco - Bug 412838 - Check for read-only resources before saving
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    Bug 336488 - DiagramEditor API
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*    mwenz - Bug 393074 - Save Editor Progress Monitor Argument
+*    fvelasco - Bug 412838 - Check for read-only resources before saving
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services;
 
 import org.eclipse.core.resources.IFile;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IGefService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IGefService.java
index 0ca0909..f6ae640 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IGefService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IGefService.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG, Redhat.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 415884 - Cannot query size of a multi-line text
- *    Aurelien Pupier - Bug 499720 - DefaultConnectionEditPolicy doesn't support scroll
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 415884 - Cannot query size of a multi-line text
+*    Aurelien Pupier - Bug 499720 - DefaultConnectionEditPolicy doesn't support scroll
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ITraceService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ITraceService.java
index 6f1a628..9d94cd6 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ITraceService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/ITraceService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 377783 - Dump for figures in connection layer needed
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 377783 - Dump for figures in connection layer needed
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IWorkbenchService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IWorkbenchService.java
index 1d7d975..94f1214 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IWorkbenchService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/IWorkbenchService.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Ali Akar, mwenz - Bug 348420 - Opening a user contributed editor
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Ali Akar, mwenz - Bug 348420 - Opening a user contributed editor
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services;
 
 import org.eclipse.graphiti.mm.pictograms.Diagram;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/CommandService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/CommandService.java
index 0c2989f..9e5e0dd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/CommandService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/CommandService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    mwenz - Bug 324859 - initial API, implementation and documentation
- *    mwenz - Bug 389380 - Undo/Redo handling wrong Command executed by undo action
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 324859 - initial API, implementation and documentation
+*    mwenz - Bug 389380 - Undo/Redo handling wrong Command executed by undo action
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/DummyExportAsImageDiagramTypeProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/DummyExportAsImageDiagramTypeProvider.java
index c539505..4e8c924 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/DummyExportAsImageDiagramTypeProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/DummyExportAsImageDiagramTypeProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015, 2015 Eclipse Modeling Project.
- * 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:
- *    Laurent Le Moux, mwenz - Bug 423018 - Direct Graphiti diagram exporter
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2015, 2019 Eclipse Modeling Project.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Laurent Le Moux, mwenz - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/EmfService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/EmfService.java
index a1f61fa..03b3954 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/EmfService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/EmfService.java
@@ -1,27 +1,24 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    mwenz - Bug 320635 - Could not open an existing diagram
- *    tkaiser - Bug 340939 - Only one instance of an Graphiti editor may exist, for each editor input
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
- *    mwenz - Bug 371513 - Save failed with NPE when switching editors
- *    mwenz - Bug 393074 - Save Editor Progress Monitor Argument
- *    fvelasco - Bug 412838 - Check for read-only resources before saving
- *    mwenz - Bug 489681 - EmfService.getFile fails with some URIs
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    mwenz - Bug 320635 - Could not open an existing diagram
+*    tkaiser - Bug 340939 - Only one instance of an Graphiti editor may exist, for each editor input
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 372753 - save shouldn't (necessarily) flush the command stack
+*    mwenz - Bug 371513 - Save failed with NPE when switching editors
+*    mwenz - Bug 393074 - Save Editor Progress Monitor Argument
+*    fvelasco - Bug 412838 - Check for read-only resources before saving
+*    mwenz - Bug 489681 - EmfService.getFile fails with some URIs
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import java.util.Collections;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ExportDiagramAsImageDummyImageProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ExportDiagramAsImageDummyImageProvider.java
index 068c13b..c9dae32 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ExportDiagramAsImageDummyImageProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ExportDiagramAsImageDummyImageProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015, 2015 Eclipse Modeling Project.
- * 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:
- *    Laurent Le Moux, mwenz - Bug 423018 - Direct Graphiti diagram exporter
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2015, 2019 Eclipse Modeling Project.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Laurent Le Moux, mwenz - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import org.eclipse.graphiti.platform.AbstractExtension;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/GefService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/GefService.java
index 1101a86..3f27dad 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/GefService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/GefService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 415884 - Cannot query size of a multi-line text
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 415884 - Cannot query size of a multi-line text
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ImageService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ImageService.java
index 6010864..530f3ef 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ImageService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/ImageService.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    mwenz - Bug 413139 - Visibility of convertImageToBytes in DefaultSaveImageFeature
- *    mjagielski - Bug 472219 - ImageService is not handling imageFilePath with protocol bundleentry
- *    Laurent Le Moux (mwenz) - Bug 423018 - Direct Graphiti diagram exporter
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    mwenz - Bug 413139 - Visibility of convertImageToBytes in DefaultSaveImageFeature
+*    mjagielski - Bug 472219 - ImageService is not handling imageFilePath with protocol bundleentry
+*    Laurent Le Moux (mwenz) - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import java.io.ByteArrayOutputStream;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/TraceService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/TraceService.java
index 28fc2b5..e07203c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/TraceService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/TraceService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 377783 - Dump for figures in connection layer needed
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 377783 - Dump for figures in connection layer needed
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import java.io.PrintWriter;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/UiLayoutService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/UiLayoutService.java
index 6d6c518..6102148 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/UiLayoutService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/UiLayoutService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 415884 - Cannot query size of a multi-line text 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 415884 - Cannot query size of a multi-line text 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/WorkbenchService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/WorkbenchService.java
index 27b86bf..1143457 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/WorkbenchService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/WorkbenchService.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Ali Akar, mwenz - Bug 348420 - Opening a user contributed editor
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 502091 - NPE in GFDirectEditManager.bringDown
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Ali Akar, mwenz - Bug 348420 - Opening a user contributed editor
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 502091 - NPE in GFDirectEditManager.bringDown
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;
 
 import org.eclipse.core.runtime.Assert;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/DataTypeTransformation.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/DataTypeTransformation.java
index b985843..07de1f7 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/DataTypeTransformation.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/DataTypeTransformation.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ModelElementNameComparator.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ModelElementNameComparator.java
index ecddea3..d609b8b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ModelElementNameComparator.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ModelElementNameComparator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util;
 
 import java.util.Comparator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ReflectionUtil.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ReflectionUtil.java
index 3a88ae6..da8cb41 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ReflectionUtil.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ReflectionUtil.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 203186 from Bug 357411 contributed by Hernan Gonzalez
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 203186 from Bug 357411 contributed by Hernan Gonzalez
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util;
 
 import java.lang.reflect.Method;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/ModelClipboard.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/ModelClipboard.java
index c9dd63e..b28517b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/ModelClipboard.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/ModelClipboard.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
- *    mwenz - Felix Velasco - Bug 361414 - Copy/paste : clipboard contents confuses the workbench
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
+*    mwenz - Felix Velasco - Bug 361414 - Copy/paste : clipboard contents confuses the workbench
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.clipboard;
 
 import java.util.ArrayList;
@@ -60,6 +57,7 @@
 import org.eclipse.swt.dnd.TextTransfer;
 import org.eclipse.swt.dnd.Transfer;
 import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.part.ResourceTransfer;
 
 /**
  * Provides a clipboard-like storage of EMF-related data based on SWT
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransfer.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransfer.java
index 73784fd..f470340 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransfer.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransfer.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.clipboard;
 
 import java.io.ByteArrayInputStream;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransferData.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransferData.java
index bf15f02..b7f3c83 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransferData.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/UriTransferData.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.clipboard;
 
 import java.util.Iterator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ChopboxAnchorFixed.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ChopboxAnchorFixed.java
index da6f147..3cf7d0d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ChopboxAnchorFixed.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ChopboxAnchorFixed.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 355968 - Only ChopboxAnchors should compute the reference point as the center of its GA
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 355968 - Only ChopboxAnchors should compute the reference point as the center of its GA
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.ChopboxAnchor;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFBendpointHandle.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFBendpointHandle.java
index eab9164..8f92cd6 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFBendpointHandle.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFBendpointHandle.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.BendpointLocator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFChopboxAnchor.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFChopboxAnchor.java
index ec7fd40..63f7ad1 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFChopboxAnchor.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFChopboxAnchor.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 336516 - Anchors with polyline GA caused NPE
- *    mgorning - Bug 355968 - Only ChopboxAnchors should compute the reference point as the center of its GA
- *    mwenz - Bug 459511 - NPE in LineSeg.getLineIntersectionsWithLineSegs when owner of GFChopboxAnchor is a Polygon
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 336516 - Anchors with polyline GA caused NPE
+*    mgorning - Bug 355968 - Only ChopboxAnchors should compute the reference point as the center of its GA
+*    mwenz - Bug 459511 - NPE in LineSeg.getLineIntersectionsWithLineSegs when owner of GFChopboxAnchor is a Polygon
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.AbstractPointListShape;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFColorConstants.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFColorConstants.java
index ee8d31a..be07cc1 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFColorConstants.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFColorConstants.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFConnectionEndpointHandle.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFConnectionEndpointHandle.java
index af94f4c..4c85c97 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFConnectionEndpointHandle.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFConnectionEndpointHandle.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.ConnectionLocator;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFCornerHandle.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFCornerHandle.java
index 73fac43..d8146a5 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFCornerHandle.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFCornerHandle.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 334233 - Fixed issue with zooming of diagrams when object in diagram is selected
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 334233 - Fixed issue with zooming of diagrams when object in diagram is selected
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.Cursors;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFHandleHelper.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFHandleHelper.java
index 783bc3c..4890d7b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFHandleHelper.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFHandleHelper.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 346487 - No selection feedback for non-resizable diagram nodes 
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 346487 - No selection feedback for non-resizable diagram nodes 
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFSurroundingHandle.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFSurroundingHandle.java
index f332509..0b71027 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFSurroundingHandle.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GFSurroundingHandle.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 365172 - Shape Selection Info Solid Line 
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 365172 - Shape Selection Info Solid Line 
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.Cursors;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GridLayer.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GridLayer.java
index 44b240f..0fb69fd 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GridLayer.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/GridLayer.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 477420 - NullPointerException in GridLayer.paintGrid (57)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 477420 - NullPointerException in GridLayer.paintGrid (57)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/LineSeg.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/LineSeg.java
index d5aae2c..b91ca5b 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/LineSeg.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/LineSeg.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.geometry.Point;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/Tooltip.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/Tooltip.java
index 5ed308c..cce2078 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/Tooltip.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/Tooltip.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *    apupier - Bug 508133 - Use FontRegistry for Tooltip
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*    apupier - Bug 508133 - Use FontRegistry for Tooltip
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.Border;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/TransparentGhostFigure.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/TransparentGhostFigure.java
index b4ee910..7503627 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/TransparentGhostFigure.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/TransparentGhostFigure.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*    mwenz - Bug 373298 - Possible Resource leaks in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingInsetsHandleLocator.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingInsetsHandleLocator.java
index 7cf5c97..9d0f4df 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingInsetsHandleLocator.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingInsetsHandleLocator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingRelativeHandleLocator.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingRelativeHandleLocator.java
index f6d4caa..8ad0bd8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingRelativeHandleLocator.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/draw2d/ZoomingRelativeHandleLocator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.draw2d;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MouseWheelHorizontalScrollHandler.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MouseWheelHorizontalScrollHandler.java
index a08dfec..41efca2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MouseWheelHorizontalScrollHandler.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MouseWheelHorizontalScrollHandler.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013 SAP AG.
- * 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:
- *    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.gef;
 
 import org.eclipse.draw2d.FigureCanvas;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MultiCreationFactory.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MultiCreationFactory.java
index 5c7a538..270d1b2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MultiCreationFactory.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/MultiCreationFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.gef;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ScalableRootEditPartAnimated.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ScalableRootEditPartAnimated.java
index e690d93..2f6f5df 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ScalableRootEditPartAnimated.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ScalableRootEditPartAnimated.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    fvelasco - Bug 403664 - Enable DoubleClickFeature on the diagram background
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.gef;
 
 import org.eclipse.draw2d.ConnectionLayer;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ZoomManagerWithAnimation.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ZoomManagerWithAnimation.java
index 249d350..69acf72 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ZoomManagerWithAnimation.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/gef/ZoomManagerWithAnimation.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.gef;
 
 import java.util.concurrent.atomic.AtomicBoolean;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleField.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleField.java
index 24f93cf..224cdc5 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleField.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleField.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui;
 
 import org.eclipse.graphiti.ui.print.IPrintPreferences;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleFieldWithDropDown.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleFieldWithDropDown.java
index ba5f61d..7306e97 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleFieldWithDropDown.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/DoubleFieldWithDropDown.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui;
 
 import org.eclipse.graphiti.ui.internal.Messages;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/PopupMenu.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/PopupMenu.java
index 5465cf9..c85b8ef 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/PopupMenu.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/PopupMenu.java
@@ -1,19 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/AbstractFigureSelectionDialog.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/AbstractFigureSelectionDialog.java
index d7bac5b..3c14778 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/AbstractFigureSelectionDialog.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/AbstractFigureSelectionDialog.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323034 - Aligned vertical gaps between groups
- *    mgorning - Bug 352874 - Exports of Diagrams > 3000x3000 px 
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323034 - Aligned vertical gaps between groups
+*    mgorning - Bug 352874 - Exports of Diagrams > 3000x3000 px 
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.print;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/DefaultPrintPreferences.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/DefaultPrintPreferences.java
index 00ef2e3..101314d 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/DefaultPrintPreferences.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/DefaultPrintPreferences.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.print;
 
 import org.eclipse.graphiti.ui.print.IPrintPreferences;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/ExportDiagramDialog.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/ExportDiagramDialog.java
index 87f1bd4..1b22179 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/ExportDiagramDialog.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/ExportDiagramDialog.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    jpasch - Bug 345315  Missing units for "Choose scale-factor
- *    mgorning - Bug 352874 - Exports of Diagrams > 3000x3000 px
- *    mwenz - Bug 375037 - ArrayIndexOutOfBoundsException when exporting diagram to SVG
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    jpasch - Bug 345315  Missing units for "Choose scale-factor
+*    mgorning - Bug 352874 - Exports of Diagrams > 3000x3000 px
+*    mwenz - Bug 375037 - ArrayIndexOutOfBoundsException when exporting diagram to SVG
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.print;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/IDiagramsExporter.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/IDiagramsExporter.java
index 72806ae..10b0564 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/IDiagramsExporter.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/IDiagramsExporter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.print;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureDialog.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureDialog.java
index a9d31ce..b090b98 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureDialog.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureDialog.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
- *    mwenz - Bug 323034 - Aligned vertical gaps between groups
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
+*    mwenz - Bug 323034 - Aligned vertical gaps between groups
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.print;
 
 import org.eclipse.draw2d.PrintFigureOperation;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureScaleableOperation.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureScaleableOperation.java
index a2fa50b..0395589 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureScaleableOperation.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/print/PrintFigureScaleableOperation.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.print;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/sfx/GFSnapFeedbackPolicy.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/sfx/GFSnapFeedbackPolicy.java
index 003abe4..3e0cdc9 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/sfx/GFSnapFeedbackPolicy.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/ui/sfx/GFSnapFeedbackPolicy.java
@@ -1,18 +1,20 @@
-/*******************************************************************************
- * Copyright (c) 2003, 2011 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
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
- *     		made class FadeIn a IDisposable
- *     		changed getLocalBackgroundColor for color management in Diagram
- *     		changed higlightGuide (smaller height and width
- *     mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2003, 2019 IBM Corporation and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*     IBM Corporation - initial API and implementation
+*     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
+*     		made class FadeIn a IDisposable
+*     		changed getLocalBackgroundColor for color management in Diagram
+*     		changed higlightGuide (smaller height and width
+*     mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.util.ui.sfx;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractImageProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractImageProvider.java
index 1eeb1cd..e8c55e1 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractImageProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractImageProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import java.util.Hashtable;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractPropertySectionFilter.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractPropertySectionFilter.java
index 849fe19..8fb16a2 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractPropertySectionFilter.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/AbstractPropertySectionFilter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.core.runtime.IAdaptable;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GFPropertySection.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GFPropertySection.java
index 73cd998..52d6799 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GFPropertySection.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GFPropertySection.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import java.beans.PropertyChangeEvent;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiConnectionEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiConnectionEditPart.java
index 7bca100..8445496 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiConnectionEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiConnectionEditPart.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - Bug 341898 - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP AG - Bug 341898 - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.core.runtime.IAdapterFactory;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiShapeEditPart.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiShapeEditPart.java
index fa5e820..8189675 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiShapeEditPart.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/GraphitiShapeEditPart.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - Bug 341898 - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP AG - Bug 341898 - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.core.runtime.IAdapterFactory;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/ICellEditorProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/ICellEditorProvider.java
index 3979b5e..8e5434c 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/ICellEditorProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/ICellEditorProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IConfigurationProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IConfigurationProvider.java
index cce5090..49611f0 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IConfigurationProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IConfigurationProvider.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IImageProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IImageProvider.java
index 0ec2601..c05e8b4 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IImageProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/IImageProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.graphiti.platform.IExtension;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/PlatformImageProvider.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/PlatformImageProvider.java
index d7b7131..047feb9 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/PlatformImageProvider.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/platform/PlatformImageProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.platform;
 
 import org.eclipse.graphiti.platform.IPlatformImageConstants;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintConfiguration.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintConfiguration.java
index 215cf2d..7dfbd7a 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintConfiguration.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintConfiguration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2013 SAP AG.
- * 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:
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.print;
 
 import org.eclipse.draw2d.IFigure;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintPreferences.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintPreferences.java
index 6e2b237..31428be 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintPreferences.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/print/IPrintPreferences.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.print;
 
 /**
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/saveasimage/ISaveAsImageConfiguration.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/saveasimage/ISaveAsImageConfiguration.java
index 16c2618..9becf45 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/saveasimage/ISaveAsImageConfiguration.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/saveasimage/ISaveAsImageConfiguration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.saveasimage;
 
 import java.util.Map;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/GraphitiUi.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/GraphitiUi.java
index 3c571d9..98c7516 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/GraphitiUi.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/GraphitiUi.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.services;
 
 import org.eclipse.graphiti.services.Graphiti;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IEmfService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IEmfService.java
index ce29785..aa18485 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IEmfService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IEmfService.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.services;
 
 import org.eclipse.emf.ecore.resource.ResourceSet;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IExtensionManager.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IExtensionManager.java
index 9ea7265..9c52fc8 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IExtensionManager.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IExtensionManager.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.services;
 
 import org.eclipse.graphiti.dt.IDiagramType;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IImageService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IImageService.java
index ebf3db9..f496cda 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IImageService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IImageService.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    mwenz - Bug 413139 - Visibility of convertImageToBytes in DefaultSaveImageFeature
- *    Laurent Le Moux (mwenz) - Bug 423018 - Direct Graphiti diagram exporter
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    mwenz - Bug 413139 - Visibility of convertImageToBytes in DefaultSaveImageFeature
+*    Laurent Le Moux (mwenz) - Bug 423018 - Direct Graphiti diagram exporter
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.services;
 
 import org.eclipse.graphiti.mm.pictograms.Diagram;
diff --git a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IUiLayoutService.java b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IUiLayoutService.java
index acf2a5e..9fc5dfc 100644
--- a/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IUiLayoutService.java
+++ b/plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/services/IUiLayoutService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 415884 - Cannot query size of a multi-line text
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 415884 - Cannot query size of a multi-line text
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.services;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/plugins/org.eclipse.graphiti/about.html b/plugins/org.eclipse.graphiti/about.html
index c258ef5..38cecbb 100644
--- a/plugins/org.eclipse.graphiti/about.html
+++ b/plugins/org.eclipse.graphiti/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/plugins/org.eclipse.graphiti/build.properties b/plugins/org.eclipse.graphiti/build.properties
index 1ca1a21..d0c2b37 100644
--- a/plugins/org.eclipse.graphiti/build.properties
+++ b/plugins/org.eclipse.graphiti/build.properties
@@ -1,19 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
-
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 bin.includes = .,\
                META-INF/,\
                plugin.properties,\
diff --git a/plugins/org.eclipse.graphiti/plugin.properties b/plugins/org.eclipse.graphiti/plugin.properties
index cf6c3db..bccfa2d 100644
--- a/plugins/org.eclipse.graphiti/plugin.properties
+++ b/plugins/org.eclipse.graphiti/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/plugins/org.eclipse.graphiti/plugin.xml b/plugins/org.eclipse.graphiti/plugin.xml
index 9b5f7ea..7e6d369 100644
--- a/plugins/org.eclipse.graphiti/plugin.xml
+++ b/plugins/org.eclipse.graphiti/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2010 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/plugins/org.eclipse.graphiti/pom.xml b/plugins/org.eclipse.graphiti/pom.xml
index 92a2452..0b7b6f6 100644
--- a/plugins/org.eclipse.graphiti/pom.xml
+++ b/plugins/org.eclipse.graphiti/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/DiagramScrollingBehavior.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/DiagramScrollingBehavior.java
index 39b25d1..6326af1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/DiagramScrollingBehavior.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/DiagramScrollingBehavior.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IDescription.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IDescription.java
index a874c75..9ba2b5b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IDescription.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IDescription.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IExecutionInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IExecutionInfo.java
index 5e8657e..a542252 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IExecutionInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IExecutionInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 import org.eclipse.graphiti.features.IFeatureAndContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IGraphicsAlgorithmHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IGraphicsAlgorithmHolder.java
index 037c668..2b8023b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IGraphicsAlgorithmHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IGraphicsAlgorithmHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IName.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IName.java
index 7113dda..0bac62f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IName.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IName.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IPropertyBag.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IPropertyBag.java
index 36d14b1..10b514b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IPropertyBag.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IPropertyBag.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnly.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnly.java
index eeea9a0..f4aa0d5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnly.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnly.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnlyProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnlyProvider.java
index 18a7ec3..7c536bc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnlyProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/IReadOnlyProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/PropertyBag.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/PropertyBag.java
index e39eb94..1c27c6a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/PropertyBag.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/PropertyBag.java
@@ -1,18 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedDimension.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedDimension.java
index 11830c2..3cfa003 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedDimension.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedDimension.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.datatypes;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedLocation.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedLocation.java
index df5660b..d89fcb9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedLocation.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IAdvancedLocation.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.datatypes;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IDimension.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IDimension.java
index cbd4da7..4094bec 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IDimension.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IDimension.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.datatypes;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/ILocation.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/ILocation.java
index b3829eb..c0de08d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/ILocation.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/ILocation.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.datatypes;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IRectangle.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IRectangle.java
index 1b3ba38..77026fc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IRectangle.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/datatypes/IRectangle.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.datatypes;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/AbstractDiagramTypeProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/AbstractDiagramTypeProvider.java
index 0000a8d..0f09650 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/AbstractDiagramTypeProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/AbstractDiagramTypeProvider.java
@@ -1,21 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    mwenz - Bug 352109 - Enable auto-update option for saved editor
- *    fvelasco - Bug 323349 - Enable external invocation of features
- *    mwenz - Bug 434684 - DiagramProvider should rewire Diagram on refresh
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    mwenz - Bug 352109 - Enable auto-update option for saved editor
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*    mwenz - Bug 434684 - DiagramProvider should rewire Diagram on refresh
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.dt;
 
 import org.eclipse.emf.ecore.resource.Resource;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramType.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramType.java
index 187b3e6..3c0466a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramType.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramType.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.dt;
 
 import org.eclipse.graphiti.platform.IExtension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProvider.java
index 0b013d8..3cac657 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProvider.java
@@ -1,21 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
- *    mwenz - Bug 352109 - Enable auto-update option for saved editor
- *    Bug 336488 - DiagramEditor API
- *    fvelasco - Bug 323349 - Enable external invocation of features
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 329523 - Add notification of DiagramTypeProvider after saving a diagram
+*    mwenz - Bug 352109 - Enable auto-update option for saved editor
+*    Bug 336488 - DiagramEditor API
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.dt;
 
 import org.eclipse.emf.ecore.resource.Resource;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProviderHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProviderHolder.java
index 4e05a20..5a0b9c8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProviderHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/dt/IDiagramTypeProviderHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.dt;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ConfigurableFeatureProviderWrapper.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ConfigurableFeatureProviderWrapper.java
index 0d1b6dd..f85dc8f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ConfigurableFeatureProviderWrapper.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ConfigurableFeatureProviderWrapper.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 /**
  * 
  */
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultFeatureProviderWrapper.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultFeatureProviderWrapper.java
index 50dd7e8..3918c52 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultFeatureProviderWrapper.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultFeatureProviderWrapper.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultResizeConfiguration.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultResizeConfiguration.java
index 90eb892..1c018de 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultResizeConfiguration.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/DefaultResizeConfiguration.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/FeatureCheckerAdapter.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/FeatureCheckerAdapter.java
index 6e11264..6cd88e8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/FeatureCheckerAdapter.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/FeatureCheckerAdapter.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddBendpointFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddBendpointFeature.java
index 25fe55f..7a5920f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddBendpointFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddBendpointFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IAddBendpointContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddFeature.java
index 3e917e6..d9c72d1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IAddFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.AbstractAddFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IContextHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IContextHolder.java
index dbce483..9c6f078 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IContextHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IContextHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICopyFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICopyFeature.java
index fd45f57..7e6815c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICopyFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICopyFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.ICopyContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateConnectionFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateConnectionFeature.java
index 6a64467..13b878a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateConnectionFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateConnectionFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 04.10.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.AbstractCreateConnectionFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateFeature.java
index 15bad99..9e14d29 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICreateFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.AbstractCreateFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomAbortableUndoRedoFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomAbortableUndoRedoFeature.java
index c945bb9..a37d25d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomAbortableUndoRedoFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomAbortableUndoRedoFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.core.runtime.OperationCanceledException;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomUndoRedoFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomUndoRedoFeature.java
index ad490c0..f02e058 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomUndoRedoFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ICustomUndoRedoFeature.java
@@ -1,18 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDeleteFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDeleteFeature.java
index 1a5b766..24b6c9d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDeleteFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDeleteFeature.java
@@ -1,24 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.func.IDelete;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingFeature.java
index 9a3d2c9..533d785 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.func.IDirectEditing;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingInfo.java
index b7629b3..a727663 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IDirectEditingInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.DefaultDirectEditingInfo;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeature.java
index b90388f..9989d6b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 388335 - Undo/Redo functionality as part of features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 388335 - Undo/Redo functionality as part of features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.IDescription;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureAndContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureAndContext.java
index 8c71962..d2967b2 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureAndContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureAndContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureChecker.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureChecker.java
index 851e4c9..fc0f8e1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureChecker.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureChecker.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureCheckerHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureCheckerHolder.java
index 63032f2..b6ce552 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureCheckerHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureCheckerHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureHolder.java
index a2b3097..9c98524 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProvider.java
index 907bd8d..3613ba9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProvider.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProviderHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProviderHolder.java
index 2e46e81..81c0510 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProviderHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IFeatureProviderHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ILayoutFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ILayoutFeature.java
index b5b03d9..43ef3ae 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ILayoutFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ILayoutFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.AbstractLayoutFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMappingProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMappingProvider.java
index 0acb383..aa71f9e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMappingProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMappingProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.emf.ecore.util.EcoreUtil;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveAnchorFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveAnchorFeature.java
index 8a8ff99..175dc98 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveAnchorFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveAnchorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IMoveAnchorContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveBendpointFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveBendpointFeature.java
index d0debd0..ff741ab 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveBendpointFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveBendpointFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IMoveBendpointContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveConnectionDecoratorFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveConnectionDecoratorFeature.java
index d9de4d3..82b87d5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveConnectionDecoratorFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveConnectionDecoratorFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IMoveConnectionDecoratorContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveFeature.java
index 4708bbf..7ebfcf5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveFeature.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveShapeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveShapeFeature.java
index 279471a..37e7149 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveShapeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IMoveShapeFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.AbstractMoveShapeFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPasteFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPasteFeature.java
index 729a386..2e992d1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPasteFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPasteFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IPasteContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPrintFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPrintFeature.java
index d159a17..15a8430 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPrintFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IPrintFeature.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IPrintContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgress.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgress.java
index 4f61672..cdd04fc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgress.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgress.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgressProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgressProvider.java
index b61a3fb..94658ca 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgressProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IProgressProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReason.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReason.java
index 16df785..243eff6 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReason.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReason.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReconnectionFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReconnectionFeature.java
index 27960a7..7168d03 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReconnectionFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IReconnectionFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.DefaultReconnectionFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveBendpointFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveBendpointFeature.java
index 3dabe28..ff93738 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveBendpointFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveBendpointFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IRemoveBendpointContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveFeature.java
index 2f46def..2768691 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IRemoveFeature.java
@@ -1,24 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.DefaultRemoveFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeConfiguration.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeConfiguration.java
index 1b9566b..5127395 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeConfiguration.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeConfiguration.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeFeature.java
index e47af86..541121c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeFeature.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.IResizeShapeContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeShapeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeShapeFeature.java
index 1dc76d1..020b344 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeShapeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IResizeShapeFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.DefaultResizeShapeFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ISaveImageFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ISaveImageFeature.java
index 017a989..7324277 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ISaveImageFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/ISaveImageFeature.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.context.ISaveImageContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IUpdateFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IUpdateFeature.java
index 3fa76f6..6b63d44 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IUpdateFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/IUpdateFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features;
 
 import org.eclipse.graphiti.features.impl.AbstractUpdateFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddBendpointContext.java
index b7ab523..370a8a0 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddBendpointContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddConnectionContext.java
index 98bee5f..4855236 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddConnectionContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddContext.java
index 6dd002b..faec10e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAddContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.ContainerShape;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAreaContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAreaContext.java
index c255a68..95e3ee5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAreaContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IAreaContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IBendpointContext.java
index 7278ef2..6662b80 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IBendpointContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.algorithms.styles.Point;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IConnectionContext.java
index e57ea6f..c3a7084 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IConnectionContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.Anchor;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IContext.java
index 9c07259..84ce5e5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.IPropertyBag;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICopyContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICopyContext.java
index 41513fa..9234791 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICopyContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICopyContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateConnectionContext.java
index 4ef8455..9ebe860 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateConnectionContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateContext.java
index 9974aac..2f00cfa 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICreateContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICustomContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICustomContext.java
index 2ccad56..42cd842 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICustomContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ICustomContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDeleteContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDeleteContext.java
index 9f2e0e4..c947c0a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDeleteContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDeleteContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDirectEditingContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDirectEditingContext.java
index 54ab9ee..e884c01 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDirectEditingContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDirectEditingContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDoubleClickContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDoubleClickContext.java
index cc664c0..9849673 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDoubleClickContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IDoubleClickContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILayoutContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILayoutContext.java
index 5f96f4a..08cad6a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILayoutContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILayoutContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILocationContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILocationContext.java
index ed542f1..c144689 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILocationContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ILocationContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveAnchorContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveAnchorContext.java
index b8f601e..7e6f7b0 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveAnchorContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveAnchorContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.Anchor;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveBendpointContext.java
index 86ec216..287c82d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveBendpointContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveConnectionDecoratorContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveConnectionDecoratorContext.java
index b9722c7..5731eb1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveConnectionDecoratorContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveConnectionDecoratorContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveContext.java
index 298c923..a420ce9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveShapeContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveShapeContext.java
index bb10fc3..8b0f63f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveShapeContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMoveShapeContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.ContainerShape;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMultiDeleteInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMultiDeleteInfo.java
index e8ed294..e087bc8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMultiDeleteInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IMultiDeleteInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPasteContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPasteContext.java
index c899cc4..20d1ffa 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPasteContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPasteContext.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 339525 - Enrich paste context with location information
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 339525 - Enrich paste context with location information
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementContext.java
index 52fb3d7..24832f9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementsContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementsContext.java
index 8dd756b..276e5ec 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementsContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPictogramElementsContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPrintContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPrintContext.java
index 519a6e9..f6f59eb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPrintContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IPrintContext.java
@@ -1,20 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IReconnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IReconnectionContext.java
index ae03a02..db3bf80 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IReconnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IReconnectionContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveBendpointContext.java
index c42f525..fef011c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveBendpointContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveContext.java
index 2e61e49..e7b6884 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IRemoveContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeContext.java
index 0db594a..6f0efad 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeShapeContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeShapeContext.java
index 79a6eb5..e2be268 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeShapeContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IResizeShapeContext.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 342262 - enhanced resize behavior for container shapes
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 342262 - enhanced resize behavior for container shapes
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.Shape;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISaveImageContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISaveImageContext.java
index 266e521..e5745c4 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISaveImageContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISaveImageContext.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISingleClickContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISingleClickContext.java
index bb31af8..680b0e1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISingleClickContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISingleClickContext.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
-+ * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 386913 - Support also Single-Click-Features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 386913 - Support also Single-Click-Features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISplitConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISplitConnectionContext.java
index c3fca2e..440bc5e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISplitConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ISplitConnectionContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.Connection;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionContext.java
index 2297512..08b844d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.Connection;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionDecoratorContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionDecoratorContext.java
index a8899ec..c050f86 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionDecoratorContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetConnectionDecoratorContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetContext.java
index 8ce89d5..5d7780e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/ITargetContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 import org.eclipse.graphiti.mm.pictograms.ContainerShape;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IUpdateContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IUpdateContext.java
index 0ab3338..915718a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IUpdateContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/IUpdateContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 30.11.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddBendpointContext.java
index 599e012..6e77619 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddBendpointContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IAddBendpointContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddConnectionContext.java
index 73fc300..0cd1c1a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddConnectionContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IAddConnectionContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddContext.java
index dc1e58d..b8d5631 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AddContext.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaAnchorContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaAnchorContext.java
index d13b829..8ea3453 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaAnchorContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaAnchorContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IMoveAnchorContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaContext.java
index 618e45c..0cb3676 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/AreaContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IAreaContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CopyContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CopyContext.java
index a30e2f4..b98e27c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CopyContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CopyContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ICopyContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateConnectionContext.java
index a65ac9f..1b628bf 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateConnectionContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateContext.java
index 185bfe4..163609f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CreateContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ICreateContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CustomContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CustomContext.java
index 0705a25..d697987 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CustomContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/CustomContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ICustomContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DeleteContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DeleteContext.java
index 7ca8fe0..5d01aa5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DeleteContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DeleteContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IDeleteContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DirectEditingContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DirectEditingContext.java
index 6132908..32c76ef 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DirectEditingContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/DirectEditingContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IDirectEditingContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LayoutContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LayoutContext.java
index 615ee5d..dd89e62 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LayoutContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LayoutContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 30.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ILayoutContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LocationContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LocationContext.java
index 5c03cf1..8893bc8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LocationContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/LocationContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ILocationContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveBendpointContext.java
index efcd80c..7f9f2d2 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveBendpointContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IMoveBendpointContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveConnectionDecoratorContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveConnectionDecoratorContext.java
index 0e5ed9c..ad5861d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveConnectionDecoratorContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveConnectionDecoratorContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IMoveConnectionDecoratorContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveContext.java
index f5345e6..e4642f9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IMoveContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveShapeContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveShapeContext.java
index 673519b..2224d12 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveShapeContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MoveShapeContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 16.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IMoveShapeContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MultiDeleteInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MultiDeleteInfo.java
index f314ab9..eb9e7fc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MultiDeleteInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/MultiDeleteInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IDeleteContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PasteContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PasteContext.java
index ea3341d..01eb6bf 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PasteContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PasteContext.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 339525 - Enrich paste context with location information
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 339525 - Enrich paste context with location information
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IPasteContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PrintContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PrintContext.java
index a5359b4..d2047fe 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PrintContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/PrintContext.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IPrintContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ReconnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ReconnectionContext.java
index 8ef3806..48022b6 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ReconnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ReconnectionContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveBendpointContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveBendpointContext.java
index 065f82d..d2195d7 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveBendpointContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveBendpointContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IRemoveBendpointContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveContext.java
index cf17278..25512de 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/RemoveContext.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 17.11.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IRemoveContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeContext.java
index 3b69496..7a64d83 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IResizeContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeShapeContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeShapeContext.java
index 261f759..5aa8b48 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeShapeContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/ResizeShapeContext.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 342262 - enhanced resize behavior for container shapes
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 342262 - enhanced resize behavior for container shapes
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IResizeShapeContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SaveImageContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SaveImageContext.java
index a112ec1..14fa48c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SaveImageContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SaveImageContext.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ISaveImageContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SplitConnectionContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SplitConnectionContext.java
index f9fa582..1915de7 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SplitConnectionContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/SplitConnectionContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.ISplitConnectionContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/UpdateContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/UpdateContext.java
index d955179..0c2dda0 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/UpdateContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/context/impl/UpdateContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 30.11.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.context.impl;
 
 import org.eclipse.graphiti.features.context.IUpdateContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractAsynchronousCustomFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractAsynchronousCustomFeature.java
index 178046c..f858a06 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractAsynchronousCustomFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractAsynchronousCustomFeature.java
@@ -1,18 +1,15 @@
-/*
- * <copyright>
- *
- * Copyright (c) 2014, IETR/INSA of Rennes
- * 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:
- *    IETR/INSA of Rennes - initial API, implementation and documentation
- *
- * </copyright>
- *
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 IETR/INSA of Rennes
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    IETR/INSA of Rennes - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.custom;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractCustomFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractCustomFeature.java
index ffe5fff..ee553f0 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractCustomFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/AbstractCustomFeature.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.custom;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/ICustomFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/ICustomFeature.java
index 7870efa..793a0bd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/ICustomFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/custom/ICustomFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.custom;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddFeature.java
index fffaa9f..6c81b89 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IAddFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddPictogramElementFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddPictogramElementFeature.java
index 1f98e65..f8b1c33 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddPictogramElementFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddPictogramElementFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddShapeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddShapeFeature.java
index 65f6388..2b3ce66 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddShapeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractAddShapeFeature.java
@@ -1,24 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.07.2005
- *
-
-
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateConnectionFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateConnectionFeature.java
index 95a20e7..c41b745 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateConnectionFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateConnectionFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 329517 - state call backs during creation of a connection
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 329517 - state call backs during creation of a connection
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.ICreateConnectionFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateFeature.java
index cc1462d..df5d49f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractCreateFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.ICreateFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractDirectEditingFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractDirectEditingFeature.java
index 89873cb..996feac 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractDirectEditingFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractDirectEditingFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IDirectEditingFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeature.java
index 636989f..ae53c89 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeature.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 363464: Return IReason to pass on information if layout has been performed
- *    mwenz - Added convenience methods for font handling
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 363464: Return IReason to pass on information if layout has been performed
+*    mwenz - Added convenience methods for font handling
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.emf.ecore.util.EcoreUtil;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeatureProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeatureProvider.java
index 9ecf1ac..7b175e2 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeatureProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractFeatureProvider.java
@@ -1,25 +1,22 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
- *    fvelasco - Bug 391506 - Canceling a feature with OperationCanceledException provoked an extra undo
- *    pjpaulin - Bug 352120 - Modified diagram linking to avoid NullPointerException. This needs to be reviewed.
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
+*    fvelasco - Bug 391506 - Canceling a feature with OperationCanceledException provoked an extra undo
+*    pjpaulin - Bug 352120 - Modified diagram linking to avoid NullPointerException. This needs to be reviewed.
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractLayoutFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractLayoutFeature.java
index f55820c..8b06381 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractLayoutFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractLayoutFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractMoveShapeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractMoveShapeFeature.java
index f751588..7f4b0f3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractMoveShapeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractMoveShapeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractPrintFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractPrintFeature.java
index 87b475e..782b6c5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractPrintFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractPrintFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2013 SAP AG.
- * 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:
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractSaveImageFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractSaveImageFeature.java
index 54979b2..b993163 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractSaveImageFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractSaveImageFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2013 SAP AG.
- * 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:
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractUpdateFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractUpdateFeature.java
index 7064bbb..a7b6a2e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractUpdateFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/AbstractUpdateFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultAddBendpointFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultAddBendpointFeature.java
index cadfc6f..c957402 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultAddBendpointFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultAddBendpointFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultDirectEditingInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultDirectEditingInfo.java
index c9f21ff..d7b63e3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultDirectEditingInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultDirectEditingInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IDirectEditingInfo;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveAnchorFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveAnchorFeature.java
index de075ef..493adbf 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveAnchorFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveAnchorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveBendpointFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveBendpointFeature.java
index 97600e2..e94f866 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveBendpointFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveBendpointFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveConnectionDecoratorFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveConnectionDecoratorFeature.java
index f049cbd..e22c919 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveConnectionDecoratorFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveConnectionDecoratorFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveShapeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveShapeFeature.java
index 72c27a6..34104bb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveShapeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultMoveShapeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultReconnectionFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultReconnectionFeature.java
index 74e44d5..c2f55cd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultReconnectionFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultReconnectionFeature.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
- *    mwenz - Bug 364035 - DefaultReconnectionFeature#reconnect should use getNewAnchor(context)
- *                         not context.getNewAnchor()
- *    Henrik Rentz-Reichert - mwenz - Bug 376544 - bug in re-connecting a connection with identical start and end anchor
- *    mlypik - Bug 401792 - Disable starting reconnection
- *    mwenz - Bug 489834 - DefaultReconnectionFeature#getNewAnchor() should be called for the connection end, not for the start
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
+*    mwenz - Bug 364035 - DefaultReconnectionFeature#reconnect should use getNewAnchor(context)
+*                         not context.getNewAnchor()
+*    Henrik Rentz-Reichert - mwenz - Bug 376544 - bug in re-connecting a connection with identical start and end anchor
+*    mlypik - Bug 401792 - Disable starting reconnection
+*    mwenz - Bug 489834 - DefaultReconnectionFeature#getNewAnchor() should be called for the connection end, not for the start
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveBendpointFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveBendpointFeature.java
index 0ea23ce..ed4ae76 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveBendpointFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveBendpointFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveFeature.java
index 8e5af3b..373178c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultRemoveFeature.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
- *    mwenz - Bug 380400 - Remove final from DefaultRemoveFeature.remove
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
+*    mwenz - Bug 380400 - Remove final from DefaultRemoveFeature.remove
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultResizeShapeFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultResizeShapeFeature.java
index bb29cce..dbb9aad 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultResizeShapeFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultResizeShapeFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 185019 from Bug 332360 contributed by Volker Wegert
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 185019 from Bug 332360 contributed by Volker Wegert
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.DefaultResizeConfiguration;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultUpdateDiagramFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultUpdateDiagramFeature.java
index 2b02c2c..0cbbc79 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultUpdateDiagramFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/DefaultUpdateDiagramFeature.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    Laurent Le Moux (mwenz) - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *    Nicole Behlen (mwenz) - Bug 477132 - Stackoverflow in DefaultUpdateDiagramFeature.canUndo
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*    Laurent Le Moux (mwenz) - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*    Nicole Behlen (mwenz) - Bug 477132 - Stackoverflow in DefaultUpdateDiagramFeature.canUndo
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import java.util.HashMap;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/IIndependenceSolver.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/IIndependenceSolver.java
index 42ad830..f3774bc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/IIndependenceSolver.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/IIndependenceSolver.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/Reason.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/Reason.java
index d86bb8f..2d909bb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/Reason.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/Reason.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import org.eclipse.graphiti.features.IReason;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/UpdateNoBoFeature.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/UpdateNoBoFeature.java
index b214579..c2982cd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/UpdateNoBoFeature.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/features/impl/UpdateNoBoFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.features.impl;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/AbstractProposalSupport.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/AbstractProposalSupport.java
index bf597f1..d0a5bee 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/AbstractProposalSupport.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/AbstractProposalSupport.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.IDirectEditingContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IAdd.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IAdd.java
index 6044b3a..50c1577 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IAdd.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IAdd.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.IAddContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreate.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreate.java
index ebe7627..5e471c8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreate.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreate.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.ICreateContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateConnection.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateConnection.java
index c15b4bb..fb5d96f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateConnection.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateConnection.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 329517 - state call backs during creation of a connection
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 329517 - state call backs during creation of a connection
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.ICreateConnectionContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateInfo.java
index 722bdd6..9d390f8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ICreateInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDelete.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDelete.java
index 55a7ed3..c0e9315 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDelete.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDelete.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2014 Volker Wegert 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:
- *    Volker Wegert - initial API, implementation and documentation:
- *                    Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 Volker Wegert and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Volker Wegert - initial API, implementation and documentation:
+*                    Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.core.runtime.OperationCanceledException;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDirectEditing.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDirectEditing.java
index 318586a..2a87c34 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDirectEditing.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IDirectEditing.java
@@ -1,20 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
- *    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Volker Wegert - Bug 332363 - Direct Editing: enable automatic resizing for combo boxes
+*    mgorning - Bug 347262 - DirectEditingFeature with TYPE_DIALOG type
+*
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.IDirectEditingFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ILayout.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ILayout.java
index 12c6206..029cfb3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ILayout.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/ILayout.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.ILayoutContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IMoveShape.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IMoveShape.java
index 2904ada..0ccf84b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IMoveShape.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IMoveShape.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.IMoveShapeContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposal.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposal.java
index 475f620..d13ef30 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposal.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposal.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposalSupport.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposalSupport.java
index dcc1425..faee71c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposalSupport.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IProposalSupport.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.IDirectEditingContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IReconnection.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IReconnection.java
index 10dff46..d2840c7 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IReconnection.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IReconnection.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
- *    mlypik - Bug 401792 - Disable starting reconnection
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 343983 - Notification for Cancelled Reconnection Events
+*    mlypik - Bug 401792 - Disable starting reconnection
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.IReconnectionContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IRemove.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IRemove.java
index 4a585ed..4109aeb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IRemove.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IRemove.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2014 Volker Wegert 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:
- *    Volker Wegert - initial API, implementation and documentation:
- *                    Bug 336828: patterns should support delete,
- *                    remove, direct editing and conditional palette
- *                    creation entry
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 Volker Wegert and others.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Volker Wegert - initial API, implementation and documentation:
+*                    Bug 336828: patterns should support delete,
+*                    remove, direct editing and conditional palette
+*                    creation entry
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.core.runtime.OperationCanceledException;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IResizeShape.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IResizeShape.java
index 7578cac..7bf955c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IResizeShape.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IResizeShape.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.context.IResizeShapeContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IUpdate.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IUpdate.java
index b68d855..b7bacf9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IUpdate.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/IUpdate.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 import org.eclipse.graphiti.features.IReason;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/Proposal.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/Proposal.java
index b71fb0d..effee96 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/Proposal.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/func/Proposal.java
@@ -1,18 +1,16 @@
 /*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.func;
 
 public class Proposal implements IProposal {
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/DefaultFeatureAndContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/DefaultFeatureAndContext.java
index 554d309..2b0eb5c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/DefaultFeatureAndContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/DefaultFeatureAndContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/ExternalPictogramLink.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/ExternalPictogramLink.java
index e72de71..28b813e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/ExternalPictogramLink.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/ExternalPictogramLink.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal;
 
 import org.eclipse.emf.common.util.BasicEList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/GraphitiPlugin.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/GraphitiPlugin.java
index 1f4c506..5d1e84d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/GraphitiPlugin.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/GraphitiPlugin.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal;
 
 import org.eclipse.core.runtime.Plugin;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/IDiagramVersion.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/IDiagramVersion.java
index d91541c..ae8b16a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/IDiagramVersion.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/IDiagramVersion.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/Messages.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/Messages.java
index 43421d6..2d9ccb1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/Messages.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/Messages.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2017 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal;
 
 import org.eclipse.osgi.util.NLS;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/AddFeatureCommandWithContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/AddFeatureCommandWithContext.java
index 45e56b3..c49492c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/AddFeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/AddFeatureCommandWithContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.features.IAddFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandContainer.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandContainer.java
index 2e4a2db..f20cf70 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandContainer.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandContainer.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandExec.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandExec.java
index 9443d45..2f589aa 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandExec.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/CommandExec.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *    fvelasco - Bug 391506 - Cancelling a feature with OperationCanceledException provoked an extra undo
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.emf.common.command.CommandStack;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DefaultExecutionInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DefaultExecutionInfo.java
index f138f3b..8096360 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DefaultExecutionInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DefaultExecutionInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DirectEditingFeatureCommandWithContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DirectEditingFeatureCommandWithContext.java
index e3c72f5..f55b065 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DirectEditingFeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/DirectEditingFeatureCommandWithContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.features.IDirectEditingFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommand.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommand.java
index 67796bd..187c46a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommand.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.IReadOnly;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommandWithContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommandWithContext.java
index 6399993..fe62736 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/FeatureCommandWithContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 04.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand.java
index 93dc3f3..03723b9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.emf.transaction.RecordingCommand;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand2.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand2.java
index 047060b..a4750b4 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand2.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GFPreparableCommand2.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.emf.common.command.Command;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GenericFeatureCommandWithContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GenericFeatureCommandWithContext.java
index 17acf73..c183cee 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GenericFeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/GenericFeatureCommandWithContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 04.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ICommand.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ICommand.java
index 1b579dd..d7e7b8a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ICommand.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ICommand.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.IDescription;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/MoveShapeFeatureCommandWithContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/MoveShapeFeatureCommandWithContext.java
index d5ecb57..2a6c757 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/MoveShapeFeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/MoveShapeFeatureCommandWithContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 05.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ResizeShapeFeatureCommandWithContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ResizeShapeFeatureCommandWithContext.java
index 11ae109..e52e2fb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ResizeShapeFeatureCommandWithContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/command/ResizeShapeFeatureCommandWithContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 05.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.command;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/AbstractContextButtonPadDeclaration.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/AbstractContextButtonPadDeclaration.java
index 29d1657..4e694a3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/AbstractContextButtonPadDeclaration.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/AbstractContextButtonPadDeclaration.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 450993 - ContextButtonPad DomainSpecificContextButtons Graphical glitch if Shape to small
- *    Aurélien Pupier : fix Bug 502049 to avoid extra spaces for Context Pad
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 450993 - ContextButtonPad DomainSpecificContextButtons Graphical glitch if Shape to small
+*    Aurélien Pupier : fix Bug 502049 to avoid extra spaces for Context Pad
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.contextbuttons;
 
 import java.awt.Point;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/IContextButtonPadDeclaration.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/IContextButtonPadDeclaration.java
index 4e4b19b..0d17008 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/IContextButtonPadDeclaration.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/IContextButtonPadDeclaration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.contextbuttons;
 
 import java.awt.Rectangle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/PositionedContextButton.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/PositionedContextButton.java
index a205d62..4809f6f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/PositionedContextButton.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/PositionedContextButton.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.contextbuttons;
 
 import java.awt.Rectangle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/SpecialContextButtonPadDeclaration.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/SpecialContextButtonPadDeclaration.java
index c24969d..5dcc6af 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/SpecialContextButtonPadDeclaration.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/SpecialContextButtonPadDeclaration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.contextbuttons;
 
 import java.awt.Rectangle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/StandardContextButtonPadDeclaration.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/StandardContextButtonPadDeclaration.java
index 6fabc3b..9f41418 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/StandardContextButtonPadDeclaration.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/contextbuttons/StandardContextButtonPadDeclaration.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.contextbuttons;
 
 import java.awt.Rectangle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/DimensionImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/DimensionImpl.java
index 6b18b5b..6cda4bc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/DimensionImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/DimensionImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.datatypes.impl;
 
 import org.eclipse.graphiti.datatypes.IAdvancedDimension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/LocationImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/LocationImpl.java
index 536be6c..4da3004 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/LocationImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/LocationImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.datatypes.impl;
 
 import org.eclipse.graphiti.datatypes.IAdvancedLocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/RectangleImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/RectangleImpl.java
index 8674462..8c1d97e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/RectangleImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/datatypes/impl/RectangleImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.datatypes.impl;
 
 import org.eclipse.graphiti.datatypes.IAdvancedDimension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/AbstractClickContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/AbstractClickContext.java
index a195802..5da1c17 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/AbstractClickContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/AbstractClickContext.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 386913 - Support also Single-Click-Features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 386913 - Support also Single-Click-Features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.features.context.impl.CustomContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DefaultContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DefaultContext.java
index afa30ef..b104b11 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DefaultContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DefaultContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 20.06.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.PropertyBag;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DetailedPictogramElementContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DetailedPictogramElementContext.java
index 7d10667..4ea88b3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DetailedPictogramElementContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DetailedPictogramElementContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DoubleClickContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DoubleClickContext.java
index 4cd8f5e..685402e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DoubleClickContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/DoubleClickContext.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 386913 - Support also Single-Click-Features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 386913 - Support also Single-Click-Features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.features.context.IDoubleClickContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementContext.java
index 691094d..6a099db 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.features.context.IPictogramElementContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementsContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementsContext.java
index f59f998..40d5497 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementsContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/PictogramElementsContext.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.features.context.IPictogramElementsContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/SingleClickContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/SingleClickContext.java
index 2f0a850..c75de52 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/SingleClickContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/features/context/impl/base/SingleClickContext.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 386913 - Support also Single-Click-Features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 386913 - Support also Single-Click-Features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.features.context.impl.base;
 
 import org.eclipse.graphiti.features.context.ISingleClickContext;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/messages.properties b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/messages.properties
index e6b723d..fb0a7cd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/messages.properties
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/messages.properties
@@ -1,19 +1,16 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2017 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+######################################################################################################################################################
 AbstractAddFeature_0_xfld=Add
 AbstractCopyFeature_0_xfld=Copy
 AbstractCreateConnectionFeature_0_xfld=Create Connection
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/GFPreferences.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/GFPreferences.java
index 56757ed..756aa0c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/GFPreferences.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/GFPreferences.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.pref;
 
 import org.eclipse.core.runtime.Platform;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/PreferenceInitializer.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/PreferenceInitializer.java
index 1caccbd..cc33749 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/PreferenceInitializer.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/pref/PreferenceInitializer.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.pref;
 
 import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/GraphitiInternal.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/GraphitiInternal.java
index cb77fe6..b96c7c5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/GraphitiInternal.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/GraphitiInternal.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services;
 
 import org.eclipse.graphiti.internal.services.impl.EmfService;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/IEmfService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/IEmfService.java
index b8055ea..bc642ff 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/IEmfService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/IEmfService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services;
 
 import org.eclipse.emf.ecore.EObject;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/AbstractServiceHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/AbstractServiceHolder.java
index f606d16..d7c8600 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/AbstractServiceHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/AbstractServiceHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import org.eclipse.graphiti.services.Graphiti;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/CreateServiceImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/CreateServiceImpl.java
index 3898a28..fe97d27 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/CreateServiceImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/CreateServiceImpl.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 184530 from Bug 331829 contributed by Henrik Rentz-Reichert
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    jpasch - Bug 352542 - Add "plain"-create methods for working with styles
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mwenz - Bug 417454 - Proposal to add an additional createDiagram() method to IPeCreateService
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 184530 from Bug 331829 contributed by Henrik Rentz-Reichert
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    jpasch - Bug 352542 - Add "plain"-create methods for working with styles
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mwenz - Bug 417454 - Proposal to add an additional createDiagram() method to IPeCreateService
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/EmfService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/EmfService.java
index 4c1f59e..095d52c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/EmfService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/EmfService.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Laurent Le Moux (mwenz) - Bug 423018 - Direct Graphiti diagram exporter
- *    mwenz - Bug 486051 - New EmfService.isObjectAlive() behaviour does not play well with GAs removal
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Laurent Le Moux (mwenz) - Bug 423018 - Direct Graphiti diagram exporter
+*    mwenz - Bug 486051 - New EmfService.isObjectAlive() behaviour does not play well with GAs removal
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import java.lang.ref.WeakReference;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LayoutServiceImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LayoutServiceImpl.java
index 3268d8e..b680fa3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LayoutServiceImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LayoutServiceImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LinkServiceImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LinkServiceImpl.java
index 49b37c2..79215c1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LinkServiceImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/LinkServiceImpl.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323359 Avoid usage of java.lang.text, ICU4J etc.
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/MigrationServiceImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/MigrationServiceImpl.java
index 808a271..40ad4da 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/MigrationServiceImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/MigrationServiceImpl.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/PeServiceImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/PeServiceImpl.java
index 08771fd..00c6b86 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/PeServiceImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/services/impl/PeServiceImpl.java
@@ -1,31 +1,28 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 184530 from Bug 331829 contributed by Henrik Rentz-Reichert
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *    mwenz - Bug 352220 - Possibility to disable guides
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mwenz - Bug 364126 - Make GaServiceImpl extensible
- *    mwenz - Bug 421813 - Relative position to diagram of active Shape nested in inactive ContainerShape is calculated incorrectly
- *    mwenz - Bug 417454 - Proposal to add an additional createDiagram() method to IPeCreateService
- *    Moritz Eysholdt,  Jerome Sivadier (mwenz) - Bug 433998 - peService.deletePictogramElement() is extremely slow
- *    mwenz - Bug 509122 - NullPointerException in PeServiceImpl.getLocationInfo
- *    mwenz - Bug 510490 - NullPointerException in PeServiceImpl.getGaBoundsForAnchor
- *    mwenz - Bug 527192 - NullPointerException in PeServiceImpl.getRelativeToDiagramX
- *    mwenz - Bug 529378 - PeServiceImpl.getConnectionMidpoint may return incorrect value when connection has no bendpoints
- *    mwenz - Bug 541129 - Connection Midpoint calculation fails for big diagrams
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 184530 from Bug 331829 contributed by Henrik Rentz-Reichert
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*    mwenz - Bug 352220 - Possibility to disable guides
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mwenz - Bug 364126 - Make GaServiceImpl extensible
+*    mwenz - Bug 421813 - Relative position to diagram of active Shape nested in inactive ContainerShape is calculated incorrectly
+*    mwenz - Bug 417454 - Proposal to add an additional createDiagram() method to IPeCreateService
+*    Moritz Eysholdt,  Jerome Sivadier (mwenz) - Bug 433998 - peService.deletePictogramElement() is extremely slow
+*    mwenz - Bug 509122 - NullPointerException in PeServiceImpl.getLocationInfo
+*    mwenz - Bug 510490 - NullPointerException in PeServiceImpl.getGaBoundsForAnchor
+*    mwenz - Bug 527192 - NullPointerException in PeServiceImpl.getRelativeToDiagramX
+*    mwenz - Bug 529378 - PeServiceImpl.getConnectionMidpoint may return incorrect value when connection has no bendpoints
+*    mwenz - Bug 541129 - Connection Midpoint calculation fails for big diagrams
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.services.impl;
 
 import java.security.InvalidParameterException;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/AbstractTracer.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/AbstractTracer.java
index 8ae710e..8c7cc94 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/AbstractTracer.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/AbstractTracer.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340443 - Fixed AbstractTracer must not implement ILog warning
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340443 - Fixed AbstractTracer must not implement ILog warning
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.util;
 
 import org.eclipse.core.runtime.ILog;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DefaultLook.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DefaultLook.java
index c3e162e..c6dbb83 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DefaultLook.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DefaultLook.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.util;
 
 import org.eclipse.graphiti.util.ColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DynamicLook.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DynamicLook.java
index f9057e7..fe379fd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DynamicLook.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/DynamicLook.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.util;
 
 import org.eclipse.graphiti.util.ColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/LookManager.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/LookManager.java
index 520b48b..8b0e34b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/LookManager.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/LookManager.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.util;
 
 import org.eclipse.graphiti.util.ILook;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/T.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/T.java
index 044d998..fbc3825 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/T.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/internal/util/T.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.internal.util;
 
 import org.eclipse.graphiti.internal.GraphitiPlugin;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/DefaultNotificationService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/DefaultNotificationService.java
index 9d492a2..e74fc7b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/DefaultNotificationService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/DefaultNotificationService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.notification;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/INotificationService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/INotificationService.java
index 5464ff0..0b721c5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/INotificationService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/notification/INotificationService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.notification;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IConnectionCreationToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IConnectionCreationToolEntry.java
index 07b64cc..e85c02f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IConnectionCreationToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IConnectionCreationToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/ICreationToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/ICreationToolEntry.java
index 69e919a..146f8bb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/ICreationToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/ICreationToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IObjectCreationToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IObjectCreationToolEntry.java
index 8309954..5a09d81 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IObjectCreationToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IObjectCreationToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 import org.eclipse.graphiti.features.ICreateFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteCompartmentEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteCompartmentEntry.java
index 35f5cf1..586f339 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteCompartmentEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteCompartmentEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteEntry.java
index 222aed3..ff3d841 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteSeparatorEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteSeparatorEntry.java
index d1bd2de..0409def 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteSeparatorEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IPaletteSeparatorEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IStackToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IStackToolEntry.java
index 8acff8e..7354c9f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IStackToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IStackToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IToolEntry.java
index 970190c..c7b7f9f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/IToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteEntry.java
index 926a36a..e8ded5e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import org.eclipse.graphiti.palette.IPaletteEntry;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteToolEntry.java
index 40e5c4f..8f52865 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/AbstractPaletteToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ConnectionCreationToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ConnectionCreationToolEntry.java
index 64b63a2..ed6380f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ConnectionCreationToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ConnectionCreationToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ObjectCreationToolEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ObjectCreationToolEntry.java
index 8029caa..a21cda8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ObjectCreationToolEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/ObjectCreationToolEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import org.eclipse.graphiti.features.ICreateFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteCompartmentEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteCompartmentEntry.java
index 6ae5a5d..c0dc420 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteCompartmentEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteCompartmentEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteSeparatorEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteSeparatorEntry.java
index bc50f7c..b00c096 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteSeparatorEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/PaletteSeparatorEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import org.eclipse.graphiti.palette.IPaletteSeparatorEntry;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/StackEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/StackEntry.java
index c4af0bf..d2d9402 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/StackEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/palette/impl/StackEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.palette.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/AbstractExtension.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/AbstractExtension.java
index 2377166..2cb41a7 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/AbstractExtension.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/AbstractExtension.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramBehavior.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramBehavior.java
index 60807ae..866f636 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramBehavior.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramBehavior.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform;
 
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramContainer.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramContainer.java
index 5ca291c..d793e6c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramContainer.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IDiagramContainer.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform;
 
 import org.eclipse.core.runtime.IProgressMonitor;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IExtension.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IExtension.java
index 8528247..cde457f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IExtension.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IExtension.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/**
- * 
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IPlatformImageConstants.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IPlatformImageConstants.java
index e6936e9..c838160 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IPlatformImageConstants.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/IPlatformImageConstants.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRenderer.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRenderer.java
index fce50d1..1e2b3bd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRenderer.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRenderer.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRendererFactory.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRendererFactory.java
index 6530ac8..3c48cc4 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRendererFactory.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IGraphicsAlgorithmRendererFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IRendererContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IRendererContext.java
index f7b55a1..bf93458 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IRendererContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IRendererContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 import org.eclipse.graphiti.IGraphicsAlgorithmHolder;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualState.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualState.java
index 8d235f9..418b9a9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualState.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualState.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateChangeListener.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateChangeListener.java
index a6fd5fa..46385bc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateChangeListener.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateChangeListener.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateHolder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateHolder.java
index 58b6ec4..9b3aa68 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateHolder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/IVisualStateHolder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/RendererContext.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/RendererContext.java
index abf8cc6..a957cbc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/RendererContext.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/RendererContext.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualState.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualState.java
index ee9c5b6..3d7a799 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualState.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualState.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualStateChangedEvent.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualStateChangedEvent.java
index e0c185a..7eae608 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualStateChangedEvent.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/platform/ga/VisualStateChangedEvent.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.platform.ga;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/Graphiti.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/Graphiti.java
index 88f8016..c1594c4 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/Graphiti.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/Graphiti.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 364126 - Make GaServiceImpl extensible
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 364126 - Make GaServiceImpl extensible
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import org.eclipse.graphiti.internal.services.impl.CreateServiceImpl;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ICreateService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ICreateService.java
index eecb637..5236828 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ICreateService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ICreateService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaCreateService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaCreateService.java
index 567a351..268a206 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaCreateService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaCreateService.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    jpasch - Bug 352542 - Add "plain"-create methods for working with styles
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    jpasch - Bug 352542 - Add "plain"-create methods for working with styles
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaLayoutService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaLayoutService.java
index e9af22f..798cdeb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaLayoutService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaLayoutService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaService.java
index 798c7b1..6c6d17f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IGaService.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *    mwenz - Bug 423573 - Angles should never be integer
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import org.eclipse.graphiti.mm.StyleContainer;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILayoutService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILayoutService.java
index fa962ed..60d34fc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILayoutService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILayoutService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILinkService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILinkService.java
index 4ac3c33..d56acee 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILinkService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/ILinkService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IMigrationService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IMigrationService.java
index 4ebf861..5dd9b1e 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IMigrationService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IMigrationService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import org.eclipse.graphiti.mm.pictograms.Diagram;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeCreateService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeCreateService.java
index 5ac703c..1dc4409 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeCreateService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeCreateService.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Patch 184530 from Bug 331829 contributed by Henrik Rentz-Reichert
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mwenz - Bug 417454 - Proposal to add an additional createDiagram() method to IPeCreateService
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Patch 184530 from Bug 331829 contributed by Henrik Rentz-Reichert
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mwenz - Bug 417454 - Proposal to add an additional createDiagram() method to IPeCreateService
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeLayoutService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeLayoutService.java
index 92bfd22..a9d77cf 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeLayoutService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeLayoutService.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeService.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeService.java
index af4dbda..44e91ff 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeService.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/IPeService.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2016 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Moritz Eysholdt,  Jerome Sivadier (mwenz) - Bug 433998 - peService.deletePictogramElement() is extremely slow
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Moritz Eysholdt,  Jerome Sivadier (mwenz) - Bug 433998 - peService.deletePictogramElement() is extremely slow
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services;
 
 import java.util.Collection;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/impl/GaServiceImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/impl/GaServiceImpl.java
index 76faf16..3016e18 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/impl/GaServiceImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/services/impl/GaServiceImpl.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    jpasch - Bug 352542 - Add "plain"-create methods for working with styles
- *    mwenz - Bug 364126 - Make GaServiceImpl extensible
- *    mwenz - Bug 423573 - Angles should never be integer
- *    mwenz - Bug 481935 - [M3] Fix NPE in GaServiceImpl line 362 on move in Chess editor
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    jpasch - Bug 352542 - Add "plain"-create methods for working with styles
+*    mwenz - Bug 364126 - Make GaServiceImpl extensible
+*    mwenz - Bug 423573 - Angles should never be integer
+*    mwenz - Bug 481935 - [M3] Fix NPE in GaServiceImpl line 362 on move in Chess editor
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.services.impl;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractContextEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractContextEntry.java
index 2ad2b5f..4968e64 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractContextEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractContextEntry.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
- *                         and called features via editor command stack to check it
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature
+*                         and called features via editor command stack to check it
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.core.runtime.IStatus;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractDecorator.java
index 37c1cbe..8c88bf6 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AbstractDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AnchorSelectionInfoImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AnchorSelectionInfoImpl.java
index 4aa15e4..4b6d206 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AnchorSelectionInfoImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/AnchorSelectionInfoImpl.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/BorderDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/BorderDecorator.java
index 1f78fe0..29273ea 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/BorderDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/BorderDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    mwenz - Bug 358255 - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 358255 - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ColorDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ColorDecorator.java
index f5bb6cd..bb679fc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ColorDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ColorDecorator.java
@@ -1,18 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    mwenz - Bug 358255 - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 358255 - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ConnectionSelectionInfoImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ConnectionSelectionInfoImpl.java
index 7868fee..652098b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ConnectionSelectionInfoImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ConnectionSelectionInfoImpl.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextButtonEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextButtonEntry.java
index d940062..de72299 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextButtonEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextButtonEntry.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextEntryHelper.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextEntryHelper.java
index 26e6f57..b6f3ecd 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextEntryHelper.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextEntryHelper.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
- *    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 376572 - Generic context buttons name changeable via getName() method
+*    cbrand - Bug 385586 - Remove,Delete, Update Action (ContextMenu, ButtonPad etc.)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.features.IDeleteFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextMenuEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextMenuEntry.java
index e9dc716..855d9bc 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextMenuEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ContextMenuEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultContextButtonPadData.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultContextButtonPadData.java
index 9d95e1b..71f58cb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultContextButtonPadData.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultContextButtonPadData.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 331290 - Allowed subclassing (JavaDoc) 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 331290 - Allowed subclassing (JavaDoc) 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultToolBehaviorProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultToolBehaviorProvider.java
index a4e46e9..92ccdff 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultToolBehaviorProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DefaultToolBehaviorProvider.java
@@ -1,27 +1,25 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2019 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *    mwenz - Bug 363796 - Make setting of selection width of connections public
- *    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
- *    mgorning - Bug 386913 - Support also Single-Click-Features
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *    fvelasco - Bug 323349 - Enable external invocation of features
- *    mwenz - Bug 421754 - Absolute position of active Shape nested in inactive ContainerShape is calculated incorrectly
- *    mwenz - Bug 428068 - Automatically unselect a tool entry in palette like 'connection creation' after execution
- *    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
- *    Hubert Guerard, mwenz - Bug 543847 - Add capability to select several PictogramElement from a selection of PictogramElement 
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*    mwenz - Bug 363796 - Make setting of selection width of connections public
+*    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
+*    mgorning - Bug 386913 - Support also Single-Click-Features
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*    mwenz - Bug 421754 - Absolute position of active Shape nested in inactive ContainerShape is calculated incorrectly
+*    mwenz - Bug 428068 - Automatically unselect a tool entry in palette like 'connection creation' after execution
+*    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
+*    Hubert Guerard, mwenz - Bug 543847 - Add capability to select several PictogramElement from a selection of PictogramElement 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.awt.Polygon;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DynamicContextMenuEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DynamicContextMenuEntry.java
index 6ef684a..e82c24f 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DynamicContextMenuEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/DynamicContextMenuEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.util.ArrayList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IAnchorSelectionInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IAnchorSelectionInfo.java
index ed70731..028da3b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IAnchorSelectionInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IAnchorSelectionInfo.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IBorderDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IBorderDecorator.java
index 727c914..e34495d 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IBorderDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IBorderDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    mwenz - Bug 358255 - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 358255 - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IColorDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IColorDecorator.java
index eb3a1eb..a8b02e3 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IColorDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IColorDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    mwenz - Bug 358255 - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 358255 - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IConnectionSelectionInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IConnectionSelectionInfo.java
index 3ec9d7c..fad013b 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IConnectionSelectionInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IConnectionSelectionInfo.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonEntry.java
index b89b8a6..5950107 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonPadData.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonPadData.java
index 0050e5d..d4402bb 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonPadData.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextButtonPadData.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.util.List;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextEntry.java
index cdf8a31..a4d5ddf 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.features.IFeature;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextMenuEntry.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextMenuEntry.java
index 34e30d9..10bf487 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextMenuEntry.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IContextMenuEntry.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IDecorator.java
index 6e87bd9..e40eab0 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IImageDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IImageDecorator.java
index ec37845..926b135 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IImageDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IImageDecorator.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ISelectionInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ISelectionInfo.java
index 39c8554..b47b02a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ISelectionInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ISelectionInfo.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.mm.algorithms.styles.LineStyle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IShapeSelectionInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IShapeSelectionInfo.java
index 7719888..fc8d90a 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IShapeSelectionInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IShapeSelectionInfo.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ITextDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ITextDecorator.java
index 6aad92a..a532b46 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ITextDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ITextDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    Andreas Graf/mwenz - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Andreas Graf/mwenz - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IToolBehaviorProvider.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IToolBehaviorProvider.java
index 6f6b1d4..66e30a1 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IToolBehaviorProvider.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/IToolBehaviorProvider.java
@@ -1,26 +1,24 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2019 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *    mwenz - Bug 363796 - Make setting of selection width of connections public
- *    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *    fvelasco - Bug 323349 - Enable external invocation of features
- *    mwenz - Bug 428068 - Automatically unselect a tool entry in palette like 'connection creation' after execution
- *    mwenz - Bug 434458 - Connections don't support Color decorators
- *    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
- *    Hubert Guerard, mwenz - Bug 543847 - Add capability to select several PictogramElement from a selection of PictogramElement
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*    mwenz - Bug 363796 - Make setting of selection width of connections public
+*    mgorning - Bug 363186 - Allow modification of selection and hover state also for anchors
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*    mwenz - Bug 428068 - Automatically unselect a tool entry in palette like 'connection creation' after execution
+*    mwenz - Bug 434458 - Connections don't support Color decorators
+*    mwenz - Bug 520392 - Hard coded error message when entering an empty string in direct editing
+*    Hubert Guerard, mwenz - Bug 543847 - Add capability to select several PictogramElement from a selection of PictogramElement
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import java.awt.Polygon;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ImageDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ImageDecorator.java
index 14564a2..f65c444 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ImageDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ImageDecorator.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/SelectionInfoImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/SelectionInfoImpl.java
index 5691a32..47e0194 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/SelectionInfoImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/SelectionInfoImpl.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.mm.algorithms.styles.LineStyle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ShapeSelectionInfoImpl.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ShapeSelectionInfoImpl.java
index 3396a65..62771af 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ShapeSelectionInfoImpl.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/ShapeSelectionInfoImpl.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/TextDecorator.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/TextDecorator.java
index 31beb04..1305d22 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/TextDecorator.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/tb/TextDecorator.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    Andreas Graf/mwenz - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Andreas Graf/mwenz - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tb;
 
 import org.eclipse.graphiti.util.IColorConstant;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorConstant.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorConstant.java
index cd421b0..f322f44 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorConstant.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorConstant.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorUtil.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorUtil.java
index 80b4a32..829113c 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorUtil.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ColorUtil.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IColorConstant.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IColorConstant.java
index 731c9e8..cbc5cd0 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IColorConstant.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IColorConstant.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IGradientType.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IGradientType.java
index caf290a..d0fd440 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IGradientType.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IGradientType.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 import org.eclipse.graphiti.mm.algorithms.styles.AdaptedGradientColoredAreas;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILocationInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILocationInfo.java
index e0bcec6..ee53c43 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILocationInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILocationInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILook.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILook.java
index 2b2d48a..f9b2611 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILook.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/ILook.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 /**
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IPredefinedRenderingStyle.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IPredefinedRenderingStyle.java
index c0fc92a..dd9bda8 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IPredefinedRenderingStyle.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/IPredefinedRenderingStyle.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 import org.eclipse.graphiti.mm.algorithms.styles.AbstractStyle;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/LocationInfo.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/LocationInfo.java
index cd1c1a0..c1064b5 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/LocationInfo.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/LocationInfo.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/PredefinedColoredAreas.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/PredefinedColoredAreas.java
index 610bea2..a5aedf9 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/PredefinedColoredAreas.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/PredefinedColoredAreas.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    cbrand - Bug 382928 - Introduce factory method(s) for easier gradient creation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/TextBuilder.java b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/TextBuilder.java
index 698c7c6..c7c12ca 100644
--- a/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/TextBuilder.java
+++ b/plugins/org.eclipse.graphiti/src/org/eclipse/graphiti/util/TextBuilder.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    Eindhoven University of Technology (Albert Hofkamp) - Bug 440796 - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Eindhoven University of Technology (Albert Hofkamp) - Bug 440796 - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.util;
 
 import java.util.ArrayList;
diff --git a/releng/org.eclipse.graphiti.releng/pom.xml b/releng/org.eclipse.graphiti.releng/pom.xml
index 2399044..28bd47e 100644
--- a/releng/org.eclipse.graphiti.releng/pom.xml
+++ b/releng/org.eclipse.graphiti.releng/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.graphiti.bot.tests/about.html b/tests/org.eclipse.graphiti.bot.tests/about.html
index c258ef5..38cecbb 100644
--- a/tests/org.eclipse.graphiti.bot.tests/about.html
+++ b/tests/org.eclipse.graphiti.bot.tests/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/tests/org.eclipse.graphiti.bot.tests/build.properties b/tests/org.eclipse.graphiti.bot.tests/build.properties
index e0919d3..27a9944 100644
--- a/tests/org.eclipse.graphiti.bot.tests/build.properties
+++ b/tests/org.eclipse.graphiti.bot.tests/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/tests/org.eclipse.graphiti.bot.tests/plugin.properties b/tests/org.eclipse.graphiti.bot.tests/plugin.properties
index 1ab7e90..2458c1a 100644
--- a/tests/org.eclipse.graphiti.bot.tests/plugin.properties
+++ b/tests/org.eclipse.graphiti.bot.tests/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Robot UI Tests
 providerName = Eclipse Modeling Project 
diff --git a/tests/org.eclipse.graphiti.bot.tests/plugin.xml b/tests/org.eclipse.graphiti.bot.tests/plugin.xml
index c923735..bfcf323 100644
--- a/tests/org.eclipse.graphiti.bot.tests/plugin.xml
+++ b/tests/org.eclipse.graphiti.bot.tests/plugin.xml
@@ -1,20 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2011 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 
 <plugin>
diff --git a/tests/org.eclipse.graphiti.bot.tests/pom.xml b/tests/org.eclipse.graphiti.bot.tests/pom.xml
index 54370e5..36f3c80 100644
--- a/tests/org.eclipse.graphiti.bot.tests/pom.xml
+++ b/tests/org.eclipse.graphiti.bot.tests/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PageObject.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PageObject.java
index dd03960..d41df10 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PageObject.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PageObject.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.pageobjects;
 
 import org.eclipse.swtbot.eclipse.gef.finder.SWTGefBot;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoDiagramEditor.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoDiagramEditor.java
index af8646c..8a8162d 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoDiagramEditor.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoDiagramEditor.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.pageobjects;
 
 import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.syncExec;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoWorkbenchPage.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoWorkbenchPage.java
index 4092cdf..d38c2ac 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoWorkbenchPage.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/pageobjects/PoWorkbenchPage.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 374918 - Let default paste use LocalSelectionTransfer
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 374918 - Let default paste use LocalSelectionTransfer
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.pageobjects;
 
 import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.syncExec;
@@ -34,8 +31,8 @@
 import org.eclipse.graphiti.bot.tests.GFOtherTests;
 import org.eclipse.graphiti.mm.pictograms.Diagram;
 import org.eclipse.graphiti.ui.editor.DiagramEditor;
-import org.eclipse.graphiti.ui.editor.IDiagramContainerUI;
 import org.eclipse.graphiti.ui.editor.DiagramEditorInput;
+import org.eclipse.graphiti.ui.editor.IDiagramContainerUI;
 import org.eclipse.graphiti.ui.services.GraphitiUi;
 import org.eclipse.swt.SWT;
 import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/AbstractGFTests.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/AbstractGFTests.java
index 2e7fc32..8faf4a5 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/AbstractGFTests.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/AbstractGFTests.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 356828 - Escaped diagram name is used as editor title
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
- *    mwenz - Bug 378342 - Cannot store more than a diagram per file
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 356828 - Escaped diagram name is used as editor title
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
+*    mwenz - Bug 378342 - Cannot store more than a diagram per file
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import static org.easymock.EasyMock.createNiceMock;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithAutoUpdateAtStartup.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithAutoUpdateAtStartup.java
index 29516fe..0adbb08 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithAutoUpdateAtStartup.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithAutoUpdateAtStartup.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature and
- *                         called features via editor command stack to check it
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature and
+*                         called features via editor command stack to check it
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithHiddenSelectionAndMarqueeTool.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithHiddenSelectionAndMarqueeTool.java
index 773fb6a..7176697 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithHiddenSelectionAndMarqueeTool.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithHiddenSelectionAndMarqueeTool.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithInvalidImageProvider.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithInvalidImageProvider.java
index 1c95b5b..0052996 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithInvalidImageProvider.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/DTPwithInvalidImageProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    mwenz - Bug 352709 - invalid image provider id crashes diagram editor
- *    mwenz - Bug 421626 - Moved from ui.test to bot.test plugin
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 352709 - invalid image provider id crashes diagram editor
+*    mwenz - Bug 421626 - Moved from ui.test to bot.test plugin
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/ExtensionManagerTest.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/ExtensionManagerTest.java
index 0c9e5bd..6be116b 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/ExtensionManagerTest.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/ExtensionManagerTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    mwenz - Bug 352709 - invalid image provider id crashes diagram editor 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 352709 - invalid image provider id crashes diagram editor 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import org.eclipse.graphiti.bot.tests.util.ITestConstants;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFDialogTests.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFDialogTests.java
index 5369c45..b824767 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFDialogTests.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFDialogTests.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Changed to create action with actual workbench part
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Changed to create action with actual workbench part
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.asyncExec;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFInteractionComponentTests.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFInteractionComponentTests.java
index dbb3f2a..19c3879 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFInteractionComponentTests.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFInteractionComponentTests.java
@@ -1,27 +1,24 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355027: Move of connection decorators when zoom level != 100 behaves weird
- *    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 363796 - Make setting of selection width of connections public
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    mwenz - Bug 396793 - Text decorators
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355027: Move of connection decorators when zoom level != 100 behaves weird
+*    Felix Velasco (mwenz) - Bug 323351 - Enable to suppress/reactivate the speed buttons
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 363796 - Make setting of selection width of connections public
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    mwenz - Bug 396793 - Text decorators
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import static org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable.syncExec;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFOtherTests.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFOtherTests.java
index 24dbbff..2a4cba2 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFOtherTests.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFOtherTests.java
@@ -1,32 +1,29 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2015 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 340627 - Features should be able to indicate cancellation
- *    mwenz - Bug 348662 - Setting tooptip to null in tool behavior provider doesn't clear up
- *                         tooltip if the associated figure has a previous tooltip
- *    mwenz - Bug 356828 - Escaped diagram name is used as editor title
- *    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature and
- *                         called features via editor command stack to check it
- *    Bug 336488 - DiagramEditor API
- *    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
- *    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
- *    mwenz - Bug 378342 - Cannot store more than a diagram per file
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 391046 - Deadlock while saving prior to refactoring operation
- *    mwenz - Bug 433650 - Editor in in dirty state after a Save
- *    mwenz - Bug 441676 - Read-only attribute is not respected in Graphiti
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 340627 - Features should be able to indicate cancellation
+*    mwenz - Bug 348662 - Setting tooptip to null in tool behavior provider doesn't clear up
+*                         tooltip if the associated figure has a previous tooltip
+*    mwenz - Bug 356828 - Escaped diagram name is used as editor title
+*    mwenz - Bug 356218 - Added hasDoneChanges updates to update diagram feature and
+*                         called features via editor command stack to check it
+*    Bug 336488 - DiagramEditor API
+*    mwenz - Bug 367204 - Correctly return the added PE inAbstractFeatureProvider's addIfPossible method
+*    mwenz - Bug 376008 - Iterating through navigation history causes exceptions
+*    mwenz - Bug 378342 - Cannot store more than a diagram per file
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 391046 - Deadlock while saving prior to refactoring operation
+*    mwenz - Bug 433650 - Editor in in dirty state after a Save
+*    mwenz - Bug 441676 - Read-only attribute is not respected in Graphiti
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import static org.easymock.EasyMock.createNiceMock;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFPackageTests.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFPackageTests.java
index b036451..536e6bf 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFPackageTests.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFPackageTests.java
@@ -1,24 +1,21 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 363539 - Enabled feature delegation via IDiagramEditor.execute method
- *    mgorning - Bug 371671 - addGraphicalRepresentation returns null in dark mode
- *    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
- *    fvelasco - Bug 396247 - ImageDescriptor changes
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE and others
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 363539 - Enabled feature delegation via IDiagramEditor.execute method
+*    mgorning - Bug 371671 - addGraphicalRepresentation returns null in dark mode
+*    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
+*    fvelasco - Bug 396247 - ImageDescriptor changes
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import static org.easymock.EasyMock.createNiceMock;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFTestSuite.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFTestSuite.java
index aef9bf1..bece55b 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFTestSuite.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/GFTestSuite.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352709 - invalid image provider id crashes diagram editor 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 352709 - invalid image provider id crashes diagram editor 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import junit.framework.Test;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/PluginWizardTests.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/PluginWizardTests.java
index ab23c36..7cf9930 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/PluginWizardTests.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/PluginWizardTests.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 388211 - New plug-in with Graphiti editor wizard adds not needed dependency to org.eclipse.ui
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 388211 - New plug-in with Graphiti editor wizard adds not needed dependency to org.eclipse.ui
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import org.eclipse.core.resources.IProject;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/TBPwithHiddenSelectionAndMarqueeTool.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/TBPwithHiddenSelectionAndMarqueeTool.java
index 41dc60c..1ce12a3 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/TBPwithHiddenSelectionAndMarqueeTool.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/TBPwithHiddenSelectionAndMarqueeTool.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2011 SAP AG.
- * 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:
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/features/DefaultCopyFeature.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/features/DefaultCopyFeature.java
index e67b998..1f552df 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/features/DefaultCopyFeature.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/features/DefaultCopyFeature.java
@@ -1,22 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 374918 - Let default paste use LocalSelectionTransfer
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 06.07.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 374918 - Let default paste use LocalSelectionTransfer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests.features;import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.features.context.ICopyContext;
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
diff --git a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/util/ITestConstants.java b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/util/ITestConstants.java
index 525a089..2654868 100644
--- a/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/util/ITestConstants.java
+++ b/tests/org.eclipse.graphiti.bot.tests/src/org/eclipse/graphiti/bot/tests/util/ITestConstants.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 348662 - Setting tooptip to null in tool behavior provider doesn't clear up
- *                         tooltip if the associated figure has a previous tooltip
- *    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 348662 - Setting tooptip to null in tool behavior provider doesn't clear up
+*                         tooltip if the associated figure has a previous tooltip
+*    mwenz - Bug 341224: Allow to hide the selection and marquee tools in the palette
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.bot.tests.util;
 
 public interface ITestConstants {
diff --git a/tests/org.eclipse.graphiti.tests/about.html b/tests/org.eclipse.graphiti.tests/about.html
index c258ef5..38cecbb 100644
--- a/tests/org.eclipse.graphiti.tests/about.html
+++ b/tests/org.eclipse.graphiti.tests/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/tests/org.eclipse.graphiti.tests/build.properties b/tests/org.eclipse.graphiti.tests/build.properties
index 37e27ae..29616a3 100644
--- a/tests/org.eclipse.graphiti.tests/build.properties
+++ b/tests/org.eclipse.graphiti.tests/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/tests/org.eclipse.graphiti.tests/plugin.properties b/tests/org.eclipse.graphiti.tests/plugin.properties
index 2528eae..a9efbaf 100644
--- a/tests/org.eclipse.graphiti.tests/plugin.properties
+++ b/tests/org.eclipse.graphiti.tests/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Unit Tests for Graphiti (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/tests/org.eclipse.graphiti.tests/pom.xml b/tests/org.eclipse.graphiti.tests/pom.xml
index 577e35f..2bc7dc8 100644
--- a/tests/org.eclipse.graphiti.tests/pom.xml
+++ b/tests/org.eclipse.graphiti.tests/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/AllTests.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/AllTests.java
index c4161ce..c71ead8 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/AllTests.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/AllTests.java
@@ -1,22 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Henrik Rentz-Reichert - mwenz - Bug 376544 - bug in re-connecting a connection with identical start and end anchor
- *    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
- *    mwenz - Bug 421754 - Absolute position of active Shape nested in inactive ContainerShape is calculated incorrectly
- *    mwenz - Bug 421813 - Relative position to diagram of active Shape nested in inactive ContainerShape is calculated incorrectly
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Henrik Rentz-Reichert - mwenz - Bug 376544 - bug in re-connecting a connection with identical start and end anchor
+*    mwenz - Bug 394801 - AddGraphicalRepresentation doesn't carry properties
+*    mwenz - Bug 421754 - Absolute position of active Shape nested in inactive ContainerShape is calculated incorrectly
+*    mwenz - Bug 421813 - Relative position to diagram of active Shape nested in inactive ContainerShape is calculated incorrectly
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests;
 
 import org.eclipse.graphiti.tests.cases.CreateServiceTest;
@@ -26,8 +23,8 @@
 import org.eclipse.graphiti.tests.cases.LinkServiceTest;
 import org.eclipse.graphiti.tests.cases.PeServiceTest;
 import org.eclipse.graphiti.tests.cases.ReconnectionTest;
-import org.eclipse.graphiti.tests.tb.DefaultToolBehaviorProviderTest;
 import org.eclipse.graphiti.tests.internal.services.impl.PeServiceImplTest;
+import org.eclipse.graphiti.tests.tb.DefaultToolBehaviorProviderTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/GFAbstractCreateTestCase.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/GFAbstractCreateTestCase.java
index 5d26014..74ec2c6 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/GFAbstractCreateTestCase.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/GFAbstractCreateTestCase.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/CreateServiceTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/CreateServiceTest.java
index 64ae594..f1ad35b 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/CreateServiceTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/CreateServiceTest.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 331715: Support for rectangular grids in diagrams
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 331715: Support for rectangular grids in diagrams
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/DefaultFeaturesTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/DefaultFeaturesTest.java
index f07095a..11445bc 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/DefaultFeaturesTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/DefaultFeaturesTest.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Bug 356218 - Added hasDoneChanges updates to update diagram feature and
- *                 called features via editor command stack to check it
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Bug 356218 - Added hasDoneChanges updates to update diagram feature and
+*                 called features via editor command stack to check it
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.easymock.EasyMock.createMock;
@@ -26,7 +23,6 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
-import junit.framework.Assert;
 
 import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
 import org.eclipse.graphiti.datatypes.ILocation;
@@ -73,6 +69,8 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 
+import junit.framework.Assert;
+
 public class DefaultFeaturesTest extends GFAbstractTestCase {
 
 	// Fixture
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/FeatureParametersTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/FeatureParametersTest.java
index fa41226..1d6088d 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/FeatureParametersTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/FeatureParametersTest.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    pjpaulin - Bug 352120 - Added required methods to inner-class IDiagramEditor
- *    mwenz - Bug 370888 - API Access to export and print
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    pjpaulin - Bug 352120 - Added required methods to inner-class IDiagramEditor
+*    mwenz - Bug 370888 - API Access to export and print
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/GaServiceTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/GaServiceTest.java
index e48edbf..2ac1a65 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/GaServiceTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/GaServiceTest.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *    mwenz - Bug 423573 - Angles should never be integer
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/LinkServiceTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/LinkServiceTest.java
index 3dbf134..35aa6d5 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/LinkServiceTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/LinkServiceTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/PeServiceTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/PeServiceTest.java
index 8461e85..7eb3f44 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/PeServiceTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/PeServiceTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.easymock.EasyMock.createMock;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/ReconnectionTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/ReconnectionTest.java
index 80515ba..5eef6f0 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/ReconnectionTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/ReconnectionTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    Henrik Rentz-Reichert - mwenz - Bug 376544 - bug in re-connecting a connection with identical start and end anchor
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Henrik Rentz-Reichert - mwenz - Bug 376544 - bug in re-connecting a connection with identical start and end anchor
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.cases;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/internal/services/impl/PeServiceImplTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/internal/services/impl/PeServiceImplTest.java
index 885fb95..80179b3 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/internal/services/impl/PeServiceImplTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/internal/services/impl/PeServiceImplTest.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2018 SAP AG.
- * 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:
- *    mwenz - Bug 421813 - Relative position to diagram of active Shape nested in inactive ContainerShape is calculated incorrectly
- *    mwenz - Bug 529378 - PeServiceImpl.getConnectionMidpoint may return incorrect value when connection has no bendpoints
- *    mwenz - Bug 541129 - Connection Midpoint calculation fails for big diagrams
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 421813 - Relative position to diagram of active Shape nested in inactive ContainerShape is calculated incorrectly
+*    mwenz - Bug 529378 - PeServiceImpl.getConnectionMidpoint may return incorrect value when connection has no bendpoints
+*    mwenz - Bug 541129 - Connection Midpoint calculation fails for big diagrams
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.internal.services.impl;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/reuse/GFAbstractTestCase.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/reuse/GFAbstractTestCase.java
index 534cfe7..59d6df2 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/reuse/GFAbstractTestCase.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/reuse/GFAbstractTestCase.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.reuse;
 
 import org.junit.BeforeClass;
diff --git a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/tb/DefaultToolBehaviorProviderTest.java b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/tb/DefaultToolBehaviorProviderTest.java
index 919d829..ce50c33 100644
--- a/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/tb/DefaultToolBehaviorProviderTest.java
+++ b/tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/tb/DefaultToolBehaviorProviderTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    mwenz - Bug 421754 - Absolute position of active Shape nested in inactive ContainerShape is calculated incorrectly
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 421754 - Absolute position of active Shape nested in inactive ContainerShape is calculated incorrectly
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.tests.tb;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/about.html b/tests/org.eclipse.graphiti.testtool.ecore/about.html
index c258ef5..38cecbb 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/about.html
+++ b/tests/org.eclipse.graphiti.testtool.ecore/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/tests/org.eclipse.graphiti.testtool.ecore/build.properties b/tests/org.eclipse.graphiti.testtool.ecore/build.properties
index 61c5edd..0dec1a8 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/build.properties
+++ b/tests/org.eclipse.graphiti.testtool.ecore/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 bin.includes = .,\
                META-INF/,\
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/plugin.properties b/tests/org.eclipse.graphiti.testtool.ecore/plugin.properties
index 1e71ee2..6aca87b 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/plugin.properties
+++ b/tests/org.eclipse.graphiti.testtool.ecore/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Sample Ecore (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/plugin.xml b/tests/org.eclipse.graphiti.testtool.ecore/plugin.xml
index 75205b4..127e783 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/plugin.xml
+++ b/tests/org.eclipse.graphiti.testtool.ecore/plugin.xml
@@ -1,19 +1,18 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2010 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <plugin>
 
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/pom.xml b/tests/org.eclipse.graphiti.testtool.ecore/pom.xml
index dcc2db7..0ef0484 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/pom.xml
+++ b/tests/org.eclipse.graphiti.testtool.ecore/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestDiagramTypeProvider.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestDiagramTypeProvider.java
index 9c3dab8..ad723e6 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestDiagramTypeProvider.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestDiagramTypeProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestFeatureProvider.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestFeatureProvider.java
index 8510ad7..7e96c8d 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestFeatureProvider.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestFeatureProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestToolBehavior.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestToolBehavior.java
index 78d2e9a..423359a 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestToolBehavior.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/TestToolBehavior.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 363796 - Make setting of selection width of connections public
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 363796 - Make setting of selection width of connections public
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore;
 
 import org.eclipse.graphiti.DiagramScrollingBehavior;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestAddAssociationFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestAddAssociationFeature.java
index b51f81f..72a5508 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestAddAssociationFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestAddAssociationFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.association;
 
 import org.eclipse.emf.ecore.EReference;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestCreateAssociationFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestCreateAssociationFeature.java
index ed03787..1c7afdd 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestCreateAssociationFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/association/TestCreateAssociationFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.association;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestAddClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestAddClassFeature.java
index 6b0282d..c122e0e 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestAddClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestAddClassFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestCreateClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestCreateClassFeature.java
index 15af486..a5800d7 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestCreateClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestCreateClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestDirectEditingClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestDirectEditingClassFeature.java
index 916fd0b..7048bc9 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestDirectEditingClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestDirectEditingClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestLayoutClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestLayoutClassFeature.java
index ba4b586..43a87c7 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestLayoutClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestLayoutClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import java.util.Collection;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestMoveClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestMoveClassFeature.java
index d78e6cd..e5a0110 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestMoveClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestMoveClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import org.eclipse.emf.ecore.EClass;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestResizeClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestResizeClassFeature.java
index 3d3e744..8e84226 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestResizeClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestResizeClassFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestUpdateClassFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestUpdateClassFeature.java
index e7674fe..191f7bf 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestUpdateClassFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/clazz/TestUpdateClassFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.clazz;
 
 import java.util.Collection;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/RenamePackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/RenamePackageFeature.java
index 72161eb..a7a933b 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/RenamePackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/RenamePackageFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import org.eclipse.emf.ecore.EPackage;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestAddPackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestAddPackageFeature.java
index 5fd492c..4bb7015 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestAddPackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestAddPackageFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 355347 - Remove setters of Graphiti's Font Interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import org.eclipse.emf.ecore.EPackage;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestCreatePackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestCreatePackageFeature.java
index 3c5aa53..b56a75d 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestCreatePackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestCreatePackageFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import org.eclipse.emf.ecore.EPackage;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestLayoutPackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestLayoutPackageFeature.java
index 6507d0f..405d342 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestLayoutPackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestLayoutPackageFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import java.util.Collection;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestMovePackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestMovePackageFeature.java
index cda97c4..6b64df5 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestMovePackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestMovePackageFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import org.eclipse.emf.ecore.EPackage;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestResizePackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestResizePackageFeature.java
index adf9f1e..3050479 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestResizePackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestResizePackageFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestUpdatePackageFeature.java b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestUpdatePackageFeature.java
index a4bdf07..0394c34 100644
--- a/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestUpdatePackageFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.ecore/src/org/eclipse/graphiti/testtool/ecore/features/pack/TestUpdatePackageFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.ecore.features.pack;
 
 import java.util.Collection;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/about.html b/tests/org.eclipse.graphiti.testtool.sketch/about.html
index c258ef5..38cecbb 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/about.html
+++ b/tests/org.eclipse.graphiti.testtool.sketch/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/tests/org.eclipse.graphiti.testtool.sketch/build.properties b/tests/org.eclipse.graphiti.testtool.sketch/build.properties
index 58e6c0d..2c16b5c 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/build.properties
+++ b/tests/org.eclipse.graphiti.testtool.sketch/build.properties
@@ -1,18 +1,15 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 
 bin.includes = .,\
                META-INF/,\
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/plugin.properties b/tests/org.eclipse.graphiti.testtool.sketch/plugin.properties
index f54015c..2011be2 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/plugin.properties
+++ b/tests/org.eclipse.graphiti.testtool.sketch/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Graphiti Sample Sketch (Incubation)
 providerName = Eclipse Modeling Project 
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/plugin.xml b/tests/org.eclipse.graphiti.testtool.sketch/plugin.xml
index 252f01a..e2fdd55 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/plugin.xml
+++ b/tests/org.eclipse.graphiti.testtool.sketch/plugin.xml
@@ -1,20 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-    <copyright>
-   
-    Copyright (c) 2005, 2012 SAP AG.
-    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:
-       SAP AG - initial API, implementation and documentation
-       mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
-   
-    </copyright>
-   
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
  -->
 <plugin>
 
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/pom.xml b/tests/org.eclipse.graphiti.testtool.sketch/pom.xml
index 476cae6..2bef01e 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/pom.xml
+++ b/tests/org.eclipse.graphiti.testtool.sketch/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/CanFigure.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/CanFigure.java
index a79902b..2d804d0 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/CanFigure.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/CanFigure.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ExpandFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ExpandFeature.java
index c12af7b..d728b65 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ExpandFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ExpandFeature.java
@@ -1,18 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    fvelasco - Bug 323349 External feature invocation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    fvelasco - Bug 323349 External feature invocation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ShrinkFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ShrinkFeature.java
index 0c9c013..7c4f2de 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ShrinkFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ShrinkFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    fvelasco - Bug 323349 External feature invocation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    fvelasco - Bug 323349 External feature invocation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchDiagramTypeProvider.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchDiagramTypeProvider.java
index 574ebea..f4d4245 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchDiagramTypeProvider.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchDiagramTypeProvider.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.dt.AbstractDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchFeatureProvider.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchFeatureProvider.java
index 6306ca8..9096a57 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchFeatureProvider.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchFeatureProvider.java
@@ -1,23 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    cbrand - Bug 378341 - Enlargement of the Line Width of Shapes isn't calculated based on the center.
- *    mwenz - Bug 396793 - Text decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    cbrand - Bug 378341 - Enlargement of the Line Width of Shapes isn't calculated based on the center.
+*    mwenz - Bug 396793 - Text decorators
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import java.util.ArrayList;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchGraphicsAlgorithmRendererFactory.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchGraphicsAlgorithmRendererFactory.java
index db31515..956e611 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchGraphicsAlgorithmRendererFactory.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchGraphicsAlgorithmRendererFactory.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.draw2d.ColorConstants;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchImageProvider.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchImageProvider.java
index 5976ba5..b7d9561 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchImageProvider.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchImageProvider.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.ui.platform.AbstractImageProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchPlugin.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchPlugin.java
index 94cd39d..5068b7d 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchPlugin.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchPlugin.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import java.net.URL;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchToolBehavior.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchToolBehavior.java
index f0806de..b79c046 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchToolBehavior.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchToolBehavior.java
@@ -1,21 +1,19 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
- *    mwenz - Bug 358255 - Add Border/Background decorators
- *    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
- *    fvelasco - Bug 323349 - Enable external invocation of features
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*    mwenz - Bug 358255 - Add Border/Background decorators
+*    mgorning - Bug 391523 - Revise getSelectionInfo...() in IToolBehaviorProvider
+*    fvelasco - Bug 323349 - Enable external invocation of features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import java.util.ArrayList;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchUtil.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchUtil.java
index 1a8c07e..2c34f3c 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchUtil.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchUtil.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeChecker.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeChecker.java
index 29875c3..04d534b 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeChecker.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeChecker.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeToolBehavior.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeToolBehavior.java
index ebae2d9..21d2b6e 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeToolBehavior.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/SketchViewerModeToolBehavior.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.dt.IDiagramTypeProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ToggleColorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ToggleColorFeature.java
index 6ca6ff0..048c4c1 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ToggleColorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ToggleColorFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    fvelasco - Bug 323349 External feature invocation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    fvelasco - Bug 323349 External feature invocation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ViewerModeChecker.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ViewerModeChecker.java
index 8daaa54..a75a80b 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ViewerModeChecker.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/ViewerModeChecker.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch;
 
 import org.eclipse.graphiti.features.FeatureCheckerAdapter;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditor.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditor.java
index 993daaf..b882328 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditor.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditor.java
@@ -1,21 +1,18 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 387971 - Features cant't be invoked from contextMenu
- *    pjpaulin - Bug 352120 - Changed to instantiate DiagramEditorImpl
- *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 387971 - Features cant't be invoked from contextMenu
+*    pjpaulin - Bug 352120 - Changed to instantiate DiagramEditorImpl
+*    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.editors;
 
 
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditorContributor.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditorContributor.java
index 5dfcfba..7ff8fee 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditorContributor.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/editors/MultiPageEditorContributor.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2011, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.editors;
 
 import org.eclipse.jface.action.Action;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AbstractColorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AbstractColorFeature.java
index ba17e70..4f539bf 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AbstractColorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AbstractColorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddAnythingFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddAnythingFeature.java
index f5bd862..6dfbc90 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddAnythingFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddAnythingFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 423573 - Angles should never be integer
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddDiagramFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddDiagramFeature.java
index 4d84276..dc7b51d 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddDiagramFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddDiagramFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddLinkFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddLinkFeature.java
index 07ad4b3..9d54622 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddLinkFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/AddLinkFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.emf.common.util.URI;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/BackgroundColorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/BackgroundColorFeature.java
index f38a730..eabfce8 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/BackgroundColorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/BackgroundColorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.examples.common.ExampleUtil;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ChangeAlignmentFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ChangeAlignmentFeature.java
index a54200b..815b0fc 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ChangeAlignmentFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ChangeAlignmentFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ClearDecoratorsFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ClearDecoratorsFeature.java
index 241899f..f81e6cc 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ClearDecoratorsFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ClearDecoratorsFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 358255 - initial API, implementation and documentation
- *    mwenz - Bug 434458 - Connections don't support Color decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 358255 - initial API, implementation and documentation
+*    mwenz - Bug 434458 - Connections don't support Color decorators
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/CornerDimensionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/CornerDimensionFeature.java
index e25a786..4cf7441 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/CornerDimensionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/CornerDimensionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.draw2d.geometry.Dimension;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DisplayDecoratorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DisplayDecoratorFeature.java
index 3832f34..f2d7966 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DisplayDecoratorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DisplayDecoratorFeature.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 358255 - initial API, implementation and documentation
- *    mwenz - Bug 396793 - Text decorators
- *    mwenz - Bug 434458 - Connections don't support Color decorators
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 358255 - initial API, implementation and documentation
+*    mwenz - Bug 396793 - Text decorators
+*    mwenz - Bug 434458 - Connections don't support Color decorators
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.draw2d.Graphics;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DoubleClickFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DoubleClickFeature.java
index 3ea83c4..d4d466a 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DoubleClickFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/DoubleClickFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/FontColorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/FontColorFeature.java
index 5c4bee1..194e726 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/FontColorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/FontColorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.examples.common.ExampleUtil;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ForegroundColorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ForegroundColorFeature.java
index 31311ab..929f6be 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ForegroundColorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ForegroundColorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.examples.common.ExampleUtil;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/GradientColorFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/GradientColorFeature.java
index 878eed8..4150fbd 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/GradientColorFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/GradientColorFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.Arrays;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LayoutContainerShapeGhostAndInnerShapeFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LayoutContainerShapeGhostAndInnerShapeFeature.java
index 977d1b9..bab7140 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LayoutContainerShapeGhostAndInnerShapeFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LayoutContainerShapeGhostAndInnerShapeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.datatypes.IDimension;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineStyleFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineStyleFeature.java
index 1cdf1bc..1a78604 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineStyleFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineStyleFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineWidthFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineWidthFeature.java
index fffcc66..7ff62a2 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineWidthFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/LineWidthFeature.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *    cbrand - Bug 378341 - Enlargement of the Line Width of Shapes isn't calculated based on the center.
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*    cbrand - Bug 378341 - Enlargement of the Line Width of Shapes isn't calculated based on the center.
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ModifyControlPointsFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ModifyControlPointsFeature.java
index 91911b6..f65a448 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ModifyControlPointsFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ModifyControlPointsFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2011, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.core.runtime.OperationCanceledException;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToBackFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToBackFeature.java
index d1a253a..051a15f 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToBackFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToBackFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToFrontFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToFrontFeature.java
index f09e182..c597012 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToFrontFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SendToFrontFeature.java
@@ -1,21 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
-/*
- * Created on 12.12.2005
- */
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SetImageAttributesFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SetImageAttributesFeature.java
index 8b51e0c..04095a1 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SetImageAttributesFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SetImageAttributesFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.emf.ecore.EAttribute;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchDeleteFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchDeleteFeature.java
index 099df8d..62aa59f 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchDeleteFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchDeleteFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchFontFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchFontFeature.java
index f5eda28..1e7cc3c 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchFontFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchFontFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.examples.common.ColoredFont;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchGhostLayoutFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchGhostLayoutFeature.java
index 9dfc23d..f8f4de1 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchGhostLayoutFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchGhostLayoutFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLabelDirectEditingFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLabelDirectEditingFeature.java
index 1939bdc..75b63e9 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLabelDirectEditingFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLabelDirectEditingFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLayoutFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLayoutFeature.java
index ff6ead9..2b9224e 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLayoutFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchLayoutFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchMoveShapeFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchMoveShapeFeature.java
index 9787083..7d699fd 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchMoveShapeFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchMoveShapeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.Collection;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchReconnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchReconnectionFeature.java
index 2d4a1f0..d3ac8c5 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchReconnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchReconnectionFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchResizeShapeFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchResizeShapeFeature.java
index e93ac0e..86c7160 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchResizeShapeFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchResizeShapeFeature.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.DefaultResizeConfiguration;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextDirectEditingFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextDirectEditingFeature.java
index 29b76aa..1fd9a57 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextDirectEditingFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextDirectEditingFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextProposalDirectEditingFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextProposalDirectEditingFeature.java
index 48ad89a..ca1bc60 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextProposalDirectEditingFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SketchTextProposalDirectEditingFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SwitchModeFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SwitchModeFeature.java
index 0a8e160..19171a9 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SwitchModeFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/SwitchModeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.IName;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ToggleDecorator.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ToggleDecorator.java
index fc96f4f..8a46079 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ToggleDecorator.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/ToggleDecorator.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems 
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems 
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import java.util.Collection;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/TransparencyFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/TransparencyFeature.java
index d88c87f..896b74e 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/TransparencyFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/TransparencyFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/CreateChannelFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/CreateChannelFeature.java
index 58e555a..351e30e 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/CreateChannelFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/CreateChannelFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.bd;
 
 import org.eclipse.graphiti.datatypes.ILocation;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/IBlockDiagramConfiguration.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/IBlockDiagramConfiguration.java
index ac240bc..2b1949d 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/IBlockDiagramConfiguration.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/bd/IBlockDiagramConfiguration.java
@@ -1,3 +1,15 @@
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.bd;
 
 /**
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateConnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateConnectionFeature.java
index 588c816..8ae73bf 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateConnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateConnectionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateSimpleConnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateSimpleConnectionFeature.java
index 14e02de..75dee6d 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateSimpleConnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/AbstractSketchCreateSimpleConnectionFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.emf.ecore.util.EcoreUtil;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateCsGhostAndInnerShapeFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateCsGhostAndInnerShapeFeature.java
index 6806cc2..675e258 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateCsGhostAndInnerShapeFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateCsGhostAndInnerShapeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateHumanFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateHumanFeature.java
index bab5459..8e2fbd6 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateHumanFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/CreateHumanFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    cbrand - Bug 378341 - Enlargement of the Line Width of Shapes isn't calculated based on the center.
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    cbrand - Bug 378341 - Enlargement of the Line Width of Shapes isn't calculated based on the center.
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.emf.common.util.EList;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCanFigureFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCanFigureFeature.java
index 324e5ce..e692c18 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCanFigureFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCanFigureFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCompositeConnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCompositeConnectionFeature.java
index 0dc5ce9..d367d2f 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCompositeConnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCompositeConnectionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2012 SAP AG.
- * 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:
- *    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Benjamin Schmeling - mwenz - Bug 367483 - Support composite connections
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import java.util.Iterator;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCurvedConnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCurvedConnectionFeature.java
index 1a36f23..8aae6d6 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCurvedConnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateCurvedConnectionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateFreeformConnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateFreeformConnectionFeature.java
index db3ebef..2d5a69a 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateFreeformConnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateFreeformConnectionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.core.runtime.OperationCanceledException;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeature.java
index 10a6ebb..d87e5d6 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeatureWithGhost.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeatureWithGhost.java
index 485eebd..0c8723c 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeatureWithGhost.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaContainerFeatureWithGhost.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaFeature.java
index 2bee428..859b2bd 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaFeature.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 342869 - Image doesn't scale the contained SWT Image on resize
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeature.java
index 402a55f..178fe39 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeatureWithGhost.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeatureWithGhost.java
index f208ce9..0abded5 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeatureWithGhost.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateGaShapeFeatureWithGhost.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateManhattanConnectionFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateManhattanConnectionFeature.java
index 3e64fc7..9f5462c 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateManhattanConnectionFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/create/SketchCreateManhattanConnectionFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.create;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreateLaneFeauture.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreateLaneFeauture.java
index 9fc1c0f..368b37e 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreateLaneFeauture.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreateLaneFeauture.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.pool;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreatePoolFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreatePoolFeature.java
index 5a59f40..4bf10c8 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreatePoolFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/CreatePoolFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.pool;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/LayoutPoolFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/LayoutPoolFeature.java
index 485e36f..75bd155 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/LayoutPoolFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/pool/LayoutPoolFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.pool;
 
 import java.util.List;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/CreateDefaultStylesFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/CreateDefaultStylesFeature.java
index 185c1cf..75340d7 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/CreateDefaultStylesFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/CreateDefaultStylesFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.style;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/IgnoreAllFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/IgnoreAllFeature.java
index acf63d7..36bfc3a 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/IgnoreAllFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/IgnoreAllFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.style;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/MakeStyleFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/MakeStyleFeature.java
index 919c7e8..0a58a6f 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/MakeStyleFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/MakeStyleFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.style;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/SetStyleFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/SetStyleFeature.java
index 51f79d3..7be4e22 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/SetStyleFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/SetStyleFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.style;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/UnsetStyleFeature.java b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/UnsetStyleFeature.java
index 133cc98..52c8c28 100644
--- a/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/UnsetStyleFeature.java
+++ b/tests/org.eclipse.graphiti.testtool.sketch/src/org/eclipse/graphiti/testtool/sketch/features/style/UnsetStyleFeature.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2010 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.testtool.sketch.features.style;
 
 import org.eclipse.graphiti.features.IFeatureProvider;
diff --git a/tests/org.eclipse.graphiti.ui.tests/about.html b/tests/org.eclipse.graphiti.ui.tests/about.html
index c258ef5..38cecbb 100644
--- a/tests/org.eclipse.graphiti.ui.tests/about.html
+++ b/tests/org.eclipse.graphiti.ui.tests/about.html
@@ -8,13 +8,13 @@
 <body lang="EN-US">
 <h2>About This Content</h2>
  
-<p>June 5, 2006</p>	
+<p>June 5, 2006</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/tests/org.eclipse.graphiti.ui.tests/build.properties b/tests/org.eclipse.graphiti.ui.tests/build.properties
index 7fc9478..cf4f3df 100644
--- a/tests/org.eclipse.graphiti.ui.tests/build.properties
+++ b/tests/org.eclipse.graphiti.ui.tests/build.properties
@@ -1,3 +1,15 @@
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
+#
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
+#
+# Contributors:
+#    SAP SE - initial API, implementation and documentation
+#
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 source.. = src/
 bin.includes = META-INF/,\
                .,\
diff --git a/tests/org.eclipse.graphiti.ui.tests/plugin.properties b/tests/org.eclipse.graphiti.ui.tests/plugin.properties
index 9c1ef5f..4f371f2 100644
--- a/tests/org.eclipse.graphiti.ui.tests/plugin.properties
+++ b/tests/org.eclipse.graphiti.ui.tests/plugin.properties
@@ -1,17 +1,14 @@
-###############################################################################
-# <copyright>
+######################################################################
+# Copyright (c) 2005, 2019 SAP SE
 #
-# Copyright (c) 2005, 2010 SAP AG.
-# 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
+# This program and the accompanying materials are made
+# available under the terms of the Eclipse Public License 2.0
+# which is available at https://www.eclipse.org/legal/epl-2.0/
 #
 # Contributors:
-#    SAP AG - initial API, implementation and documentation
+#    SAP SE - initial API, implementation and documentation
 #
-# </copyright>
-#
-###############################################################################
+# SPDX-License-Identifier: EPL-2.0
+#######################################################################
 pluginName = Unit Tests for org.eclipse.graphiti.ui
 providerName = Eclipse Modeling Project 
diff --git a/tests/org.eclipse.graphiti.ui.tests/plugin.xml b/tests/org.eclipse.graphiti.ui.tests/plugin.xml
index 304ca14..3267c43 100644
--- a/tests/org.eclipse.graphiti.ui.tests/plugin.xml
+++ b/tests/org.eclipse.graphiti.ui.tests/plugin.xml
@@ -1,5 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
+<!--
+**********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+***********************************************************************
+-->
 <plugin>
    <extension
          point="org.eclipse.graphiti.ui.diagramTypes">
diff --git a/tests/org.eclipse.graphiti.ui.tests/pom.xml b/tests/org.eclipse.graphiti.ui.tests/pom.xml
index 78c4f7e..3bcf374 100644
--- a/tests/org.eclipse.graphiti.ui.tests/pom.xml
+++ b/tests/org.eclipse.graphiti.ui.tests/pom.xml
@@ -1,4 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Copyright (c) 2005, 2019 SAP SE
+   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
+-->
 <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/maven-v4_0_0.xsd">
 	<modelVersion>4.0.0</modelVersion>
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeatureTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeatureTest.java
index 9f35bf5..acfcfc8 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeatureTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultDeleteFeatureTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import static org.junit.Assert.fail;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultRemoveFeatureTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultRemoveFeatureTest.java
index 3b7d194..ff5c88d 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultRemoveFeatureTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/features/DefaultRemoveFeatureTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.features;
 
 import static org.junit.Assert.fail;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommandTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommandTest.java
index 3287d66..b3f449e 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommandTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/command/CreateConnectionCommandTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015, 2015 SAP AG.
- * 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:
- *    mwenz - Bug 470455 - Difficulty in creating associations
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2015, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 470455 - Difficulty in creating associations
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.command;
 
 import static org.junit.Assert.assertTrue;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRootTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRootTest.java
index 56b07a3..6163c97 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRootTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/editor/GFPaletteRootTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2015, 2015 SAP AG.
- * 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:
- *    mwenz - Bug 467476 - NullPointerException in GFPaletteRoot.createModelIndependentTools
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2015, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 467476 - NullPointerException in GFPaletteRoot.createModelIndependentTools
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.editor;
 
 import static org.junit.Assert.fail;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtilTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtilTest.java
index 9990f77..1cf2433 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtilTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/internal/figures/GFFigureUtilTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation (Bug 416039 - TextStyle rendering does not fall back to abstract text font)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP AG - initial API, implementation and documentation (Bug 416039 - TextStyle rendering does not fall back to abstract text font)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;
 
 import static org.junit.Assert.assertNotNull;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/AllTests.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/AllTests.java
index b8ef0b4..d246606 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/AllTests.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/AllTests.java
@@ -1,27 +1,24 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2018 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
- *    mwenz - Bug 415884 - Cannot query size of a multi-line text
- *    mwenz - Bug 423573 - Angles should never be integer
- *    mwenz - Bug 416039 - TextStyle rendering does not fall back to abstract text font
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
- *    mwenz - Bug 467476 - NullPointerException in GFPaletteRoot.createModelIndependentTools
- *    mwenz - Bug 470455 - Difficulty in creating associations
- *    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 324859 - Need Undo/Redo support for Non-EMF based domain objects
+*    mwenz - Bug 415884 - Cannot query size of a multi-line text
+*    mwenz - Bug 423573 - Angles should never be integer
+*    mwenz - Bug 416039 - TextStyle rendering does not fall back to abstract text font
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*    mwenz - Bug 453553 - Provide an abort possibility for delete and remove features in case 'pre' methods fail
+*    mwenz - Bug 467476 - NullPointerException in GFPaletteRoot.createModelIndependentTools
+*    mwenz - Bug 470455 - Difficulty in creating associations
+*    mwenz - Bug 472955 - Remove ICustomUndoableFeature and ICustomUndoablePattern deprecated in Graphiti 0.12.0
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import org.eclipse.graphiti.ui.features.DefaultDeleteFeatureTest;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandStackTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandStackTest.java
index 4bac8d8..c28afb8 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandStackTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandStackTest.java
@@ -1,20 +1,17 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 351053 - Remove the need for WorkspaceCommandStackImpl
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 351053 - Remove the need for WorkspaceCommandStackImpl
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.junit.Assert.assertNull;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandTest.java
index 3c17fe8..38054bd 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CommandTest.java
@@ -1,19 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2012, 2013 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mlypik - Bug 401792 - Disable starting reconnection
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2012, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mlypik - Bug 401792 - Disable starting reconnection
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.easymock.EasyMock.createNiceMock;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CustomUndoRedoFeatureTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CustomUndoRedoFeatureTest.java
index edb897d..dc69346 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CustomUndoRedoFeatureTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/CustomUndoRedoFeatureTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 443304 - Improve undo/redo handling in Graphiti features
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.junit.Assert.assertEquals;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/LayoutServiceTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/LayoutServiceTest.java
index bbe895e..93b25cf 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/LayoutServiceTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/LayoutServiceTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2013, 2013 SAP AG.
- * 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:
- *    mwenz - Bug 415884 - Cannot query size of a multi-line text
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2013, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 415884 - Cannot query size of a multi-line text
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.junit.Assert.fail;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/MigrationServiceTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/MigrationServiceTest.java
index f8bd2e8..084d1a4 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/MigrationServiceTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/MigrationServiceTest.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2011 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.junit.Assert.assertFalse;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/PackageTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/PackageTest.java
index 770abe2..779347f 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/PackageTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/PackageTest.java
@@ -1,22 +1,20 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
- *            DefaultSaveImageFeature
- *    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
- *    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
- *    mwenz - Bug 423573 - Angles should never be integer
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP SE - initial API, implementation and documentation
+*    mwenz - Bug 323155 - Check usage scenarios for DefaultPrintFeature and
+*            DefaultSaveImageFeature
+*    cbrand - Bug 376585 - Clean-up deprecations in Graphiti
+*    Philip Alldredge - Bug 418676 - Undo is not disabled when canUndo is false for Palette features
+*    mwenz - Bug 423573 - Angles should never be integer
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.easymock.EasyMock.createMock;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/ResourceManagerTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/ResourceManagerTest.java
index f34a58d..618f64b 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/ResourceManagerTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/ResourceManagerTest.java
@@ -1,13 +1,15 @@
-/*******************************************************************************
- * Copyright (c) 2016 iSencia Belgium NV.
- * 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:
- *    Erwin De Ley - initial implementation
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2016, 2019 iSencia Belgium NV.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    Erwin De Ley - initial implementation
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.junit.Assert.assertNotNull;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/RollbackTest.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/RollbackTest.java
index e3f745b..9885fa3 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/RollbackTest.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/RollbackTest.java
@@ -1,20 +1,16 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2005, 2012 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation
- *    mwenz - Bug 352220 - Possibility to disable guides
- *    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2005, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    mwenz - Bug 352220 - Possibility to disable guides
+*    cbrand - Bug 377475 - Fix AbstractCustomFeature.execute and canExecute
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests;
 
 import static org.junit.Assert.assertFalse;
diff --git a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/compatibility/CompatibilityTests.java b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/compatibility/CompatibilityTests.java
index bb42da5..6c324e6 100644
--- a/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/compatibility/CompatibilityTests.java
+++ b/tests/org.eclipse.graphiti.ui.tests/src/org/eclipse/graphiti/ui/tests/compatibility/CompatibilityTests.java
@@ -1,18 +1,15 @@
-/*******************************************************************************
- * <copyright>
- *
- * Copyright (c) 2014, 2014 SAP AG.
- * 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:
- *    SAP AG - initial API, implementation and documentation (Bug 423573 - Angles should never be integer)
- *
- * </copyright>
- *
- *******************************************************************************/
+/*********************************************************************
+* Copyright (c) 2014, 2019 SAP SE
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* Contributors:
+*    SAP AG - initial API, implementation and documentation (Bug 423573 - Angles should never be integer)
+*
+* SPDX-License-Identifier: EPL-2.0
+**********************************************************************/
 package org.eclipse.graphiti.ui.tests.compatibility;
 
 import static org.junit.Assert.assertEquals;
