diff --git a/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/feature.properties
index 4a4d082..ac9723f 100644
--- a/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/feature.properties
@@ -36,7 +36,7 @@
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for Data Tools Platform Connectivity
 #
 featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
 #
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.connectivity.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/feature.properties b/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/feature.properties
index 3febd7e..ebd3421 100644
--- a/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/feature.properties
+++ b/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/feature.properties
@@ -25,7 +25,7 @@
 updateSiteName=Data Tools Platform (DTP) Updates
 
 # "description" property - description of the feature
-description=Binaries Data Tools Platform Open Data Access Designer
+description=Binaries for Data Tools Platform Open Data Access Designer Core
 #
 featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
diff --git a/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/feature.properties
index 62bd466..7dd3b9e 100644
--- a/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/feature.properties
@@ -30,15 +30,15 @@
 # This file should be translated.
 
 # "featureName" property - name of the feature
-featureName=Data Tools Platform Open Data Access Designer Source
+featureName=Data Tools Platform Open Data Access Designer Core Source
 
 # "providerName" property - name of the company that provides the feature
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for Data Tools Platform Open Data Access Designer Core
 #
-featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
+featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 # "licenseURL" property - URL of the "Feature License"
 # do not translate value - just change to point to a locale-specific HTML page
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.connectivity.oda.designer.core.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.connectivity.oda.designer.feature/feature.properties b/features/org.eclipse.datatools.connectivity.oda.designer.feature/feature.properties
index 02629af..f9af69a 100644
--- a/features/org.eclipse.datatools.connectivity.oda.designer.feature/feature.properties
+++ b/features/org.eclipse.datatools.connectivity.oda.designer.feature/feature.properties
@@ -25,7 +25,7 @@
 updateSiteName=Data Tools Platform (DTP) Updates
 
 # "description" property - description of the feature
-description=Binaries Data Tools Platform Open Data Access Designer
+description=Binaries for Data Tools Platform Open Data Access Designer
 #
 featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
diff --git a/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/feature.properties
index 3d8db08..f7f43e4 100644
--- a/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/feature.properties
@@ -36,9 +36,9 @@
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for Data Tools Platform Open Data Access Designer
 #
-featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
+featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 # "licenseURL" property - URL of the "Feature License"
 # do not translate value - just change to point to a locale-specific HTML page
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.connectivity.oda.designer.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/feature.properties
index b774dac..f745679 100644
--- a/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/feature.properties
@@ -36,9 +36,9 @@
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for Data Tools Platform Open Data Access Runtime
 #
-featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
+featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 # "licenseURL" property - URL of the "Feature License"
 # do not translate value - just change to point to a locale-specific HTML page
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.connectivity.oda.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/feature.properties
index 64c2249..5bb381e 100644
--- a/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.apache.derby.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/feature.properties
index 75598f5..80e5e17 100644
--- a/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/feature.properties
index 81a8d0c..5c4ceae 100644
--- a/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.hsqldb.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/feature.properties
index 1cede26..ca612fb 100644
--- a/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.ibm.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/feature.properties
index af98a83..372fbab 100644
--- a/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.ingres.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/feature.properties
index 464a624..ac88da9 100644
--- a/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.jdbc.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/feature.properties
index 2b1bd14..86af7e2 100644
--- a/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.jdt.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/feature.properties
index 54d4814..bf32d84 100644
--- a/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.msft.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/feature.properties
index 4d55c97..c25b641 100644
--- a/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.mysql.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.oda.designer.feature/feature.properties b/features/org.eclipse.datatools.enablement.oda.designer.feature/feature.properties
index 6602276..b8b7dfb 100644
--- a/features/org.eclipse.datatools.enablement.oda.designer.feature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.oda.designer.feature/feature.properties
@@ -25,7 +25,7 @@
 updateSiteName=Data Tools Platform (DTP) Updates
 
 # "description" property - description of the feature
-description=Design support for the ODA XML and web services drivers 
+description=Binaries for the ODA Data Source Drivers Design Support
 #
 featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
diff --git a/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/feature.properties
index 453a6dc..0bac400 100644
--- a/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/feature.properties
@@ -36,9 +36,9 @@
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for the ODA Data Source Drivers Design Support
 #
-featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
+featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 # "licenseURL" property - URL of the "Feature License"
 # do not translate value - just change to point to a locale-specific HTML page
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.oda.designer.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/feature.properties
index 65cf7fc..a5f50c1 100644
--- a/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/feature.properties
@@ -30,15 +30,15 @@
 # This file should be translated.
 
 # "featureName" property - name of the feature
-featureName=Data Tools Platform Enablement for ODA Runtime Source
+featureName=Data Tools Platform Enablement for ODA ECore Driver Source
 
 # "providerName" property - name of the company that provides the feature
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for Data Tools Platform Enablement ODA ECore Driver
 #
-featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
+featureCopyright = Copyright (c) 2004, 2014 Actuate 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
 #
 # "licenseURL" property - URL of the "Feature License"
 # do not translate value - just change to point to a locale-specific HTML page
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.oda.ecore.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.oda.feature/feature.properties b/features/org.eclipse.datatools.enablement.oda.feature/feature.properties
index 2eaf276..f6459d9 100644
--- a/features/org.eclipse.datatools.enablement.oda.feature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.oda.feature/feature.properties
@@ -25,7 +25,7 @@
 updateSiteName=Data Tools Platform (DTP) Updates
 
 # "description" property - description of the feature
-description=Drivers for the ODA framework, including XML and web services
+description=Binaries for the ODA Data Source Drivers Runtime
 #
 featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
diff --git a/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/feature.properties
index 65cf7fc..7bc106e 100644
--- a/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/feature.properties
@@ -36,9 +36,9 @@
 providerName=Eclipse Data Tools Platform
 
 # "description" property - description of the feature
-description=Datatools Source
+description=Source for the ODA Data Source Drivers Runtime
 #
-featureCopyright = Copyright (c) 2009 Sybase, Inc. 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
+featureCopyright = Copyright (c) 2004, 2014 Actuate Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 #
 # "licenseURL" property - URL of the "Feature License"
 # do not translate value - just change to point to a locale-specific HTML page
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.oda.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/feature.properties
index 9795297..d2bee37 100644
--- a/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.oracle.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/feature.properties
index 9706aa9..42ebfdf 100644
--- a/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.postgresql.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/feature.properties
index 4f636bb..5a0d243 100644
--- a/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.sap.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/feature.properties
index 586589c..39a69a4 100644
--- a/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.sdk.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/feature.properties
index 3e80253..79981d4 100644
--- a/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.sqlite.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/feature.properties
index 009a709..55379ad 100644
--- a/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.enablement.sybase.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/feature.properties
index d54ecc5..c3afcda 100644
--- a/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.modelbase.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/feature.properties
index f7f6e11..d9822a2 100644
--- a/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sdk.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/feature.properties
index e96bea9..ecb4215 100644
--- a/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.data.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/feature.properties
index b99f4fa..b35044a 100644
--- a/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.ddl.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/feature.properties
index bc70ac5..8d7ecc4 100644
--- a/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.ddlgen.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/feature.properties
index cefed55..3f80209 100644
--- a/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/feature.properties
index c35f315..dfe8005 100644
--- a/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.parsers.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/feature.properties
index 9e3febe..805f4a7 100644
--- a/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.results.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/feature.properties
index 2eaf9a5..9daf59c 100644
--- a/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.schemaobjecteditor.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
diff --git a/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/feature.properties b/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/feature.properties
index 91868ca..577d514 100644
--- a/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/feature.properties
+++ b/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/feature.properties
@@ -50,7 +50,7 @@
 # should be plain text version of license agreement pointed to be "licenseURL"
 license=\
 Eclipse Foundation Software User Agreement\n\
-February 1, 2011\n\
+April 9, 2014\n\
 \n\
 Usage Of Content\n\
 \n\
@@ -123,7 +123,6 @@
        - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
        - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
        - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
-       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
        - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
 \n\
 IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
diff --git a/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/license.html b/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/license.html
index f19c483..c3d34c3 100644
--- a/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/license.html
+++ b/features/org.eclipse.datatools.sqldevtools.sqlbuilder.feature/sourceTemplateFeature/license.html
@@ -8,7 +8,7 @@
 
 <body lang="EN-US">
 <h2>Eclipse Foundation Software User Agreement</h2>
-<p>February 1, 2011</p>
+<p>April 9, 2014</p>
 
 <h3>Usage Of Content</h3>
 
@@ -62,7 +62,6 @@
        <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>
 
