diff --git a/core/org.eclipse.stem.definitions/META-INF/MANIFEST.MF b/core/org.eclipse.stem.definitions/META-INF/MANIFEST.MF
index 39d4084..8bcc800 100644
--- a/core/org.eclipse.stem.definitions/META-INF/MANIFEST.MF
+++ b/core/org.eclipse.stem.definitions/META-INF/MANIFEST.MF
@@ -1,10 +1,10 @@
 Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
-Bundle-SymbolicName: org.eclipse.stem.definitions; singleton:=true
+Bundle-SymbolicName: org.eclipse.stem.definitions;singleton:=true
 Bundle-Version: 3.0.0.qualifier
 Bundle-ClassPath: .
-Bundle-Activator: org.eclipse.stem.definitions.Activator
+Bundle-Activator: org.eclipse.stem.definitions.edges.provider.DefinitionsEditPlugin$Implementation
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Export-Package: org.eclipse.stem.definitions,
@@ -15,6 +15,7 @@
  org.eclipse.stem.definitions.adapters.spatial.geo.preferences,
  org.eclipse.stem.definitions.edges,
  org.eclipse.stem.definitions.edges.impl,
+ org.eclipse.stem.definitions.edges.presentation,
  org.eclipse.stem.definitions.edges.provider,
  org.eclipse.stem.definitions.edges.util,
  org.eclipse.stem.definitions.functions,
@@ -36,7 +37,12 @@
  org.eclipse.stem.definitions.types.util
 Require-Bundle: org.eclipse.core.runtime,
  org.eclipse.core.resources;visibility:=reexport,
+ org.eclipse.emf.ecore;visibility:=reexport,
  org.eclipse.stem.core;visibility:=reexport,
+ org.eclipse.emf.edit;visibility:=reexport,
+ org.eclipse.emf.ecore.edit;visibility:=reexport,
+ org.eclipse.emf.ecore.xmi;visibility:=reexport,
+ org.eclipse.emf.edit.ui;visibility:=reexport,
  org.eclipse.stem.geography,
  org.eclipse.ui.ide;visibility:=reexport
 Bundle-ActivationPolicy: lazy
diff --git a/core/org.eclipse.stem.definitions/icons/full/obj16/DoubleLabelValue.gif b/core/org.eclipse.stem.definitions/icons/full/obj16/DoubleLabelValue.gif
new file mode 100644
index 0000000..48e3cf2
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/icons/full/obj16/DoubleLabelValue.gif
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/icons/full/obj16/GenericLabelValue.gif b/core/org.eclipse.stem.definitions/icons/full/obj16/GenericLabelValue.gif
new file mode 100644
index 0000000..cb1755a
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/icons/full/obj16/GenericLabelValue.gif
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/icons/full/obj16/IntegerLabelValue.gif b/core/org.eclipse.stem.definitions/icons/full/obj16/IntegerLabelValue.gif
new file mode 100644
index 0000000..b3643da
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/icons/full/obj16/IntegerLabelValue.gif
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/icons/full/obj16/KeyValueLabelValue.gif b/core/org.eclipse.stem.definitions/icons/full/obj16/KeyValueLabelValue.gif
new file mode 100644
index 0000000..90d10f9
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/icons/full/obj16/KeyValueLabelValue.gif
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/icons/full/obj16/LongLabelValue.gif b/core/org.eclipse.stem.definitions/icons/full/obj16/LongLabelValue.gif
new file mode 100644
index 0000000..89ad5da
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/icons/full/obj16/LongLabelValue.gif
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/icons/full/obj16/StringLabelValue.gif b/core/org.eclipse.stem.definitions/icons/full/obj16/StringLabelValue.gif
new file mode 100644
index 0000000..afb82ea
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/icons/full/obj16/StringLabelValue.gif
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/model/definitions.genmodel b/core/org.eclipse.stem.definitions/model/definitions.genmodel
index 3f78f0d..1e549a5 100644
--- a/core/org.eclipse.stem.definitions/model/definitions.genmodel
+++ b/core/org.eclipse.stem.definitions/model/definitions.genmodel
@@ -1,12 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<genmodel:GenModel xmi:version="2.0"
-    xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText=""
-    modelDirectory="/org.eclipse.stem.definitions/src" editDirectory="/org.eclipse.stem.definitions/src"
-    editorDirectory="/org.eclipse.stem.definitions/src" modelPluginID="org.eclipse.stem.definitions"
-    redirection="" modelName="Definitions" nonNLSMarkers="true" testsDirectory="/org.eclipse.stem.tests.definitions/src"
-    importerID="org.eclipse.emf.importer.ecore" complianceLevel="5.0" copyrightFields="false"
-    runtimeVersion="2.6" usedGenPackages="../../org.eclipse.stem.core/model/core.genmodel#//graph ../../org.eclipse.stem.core/model/core.genmodel#//common ../../org.eclipse.stem.core/model/core.genmodel#//model platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.stem.core/model/core.genmodel#//modifier ../../org.eclipse.stem.core/model/core.genmodel#//scenario ../../org.eclipse.stem.core/model/core.genmodel#//sequencer ../../org.eclipse.stem.core/model/core.genmodel#//solver ../../org.eclipse.stem.core/model/core.genmodel#//logger">
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="" modelDirectory="/org.eclipse.stem.definitions/src"
+    editDirectory="/org.eclipse.stem.definitions/src" editorDirectory="/org.eclipse.stem.definitions/src"
+    modelPluginID="org.eclipse.stem.definitions" redirection="" modelName="Definitions"
+    nonNLSMarkers="true" testsDirectory="/org.eclipse.stem.tests.definitions/src"
+    importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0" copyrightFields="false"
+    runtimeVersion="2.9" usedGenPackages="../../org.eclipse.stem.core/model/core.genmodel#//graph ../../org.eclipse.stem.core/model/core.genmodel#//common ../../org.eclipse.stem.core/model/core.genmodel#//model platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore ../../org.eclipse.stem.core/model/core.genmodel#//modifier ../../org.eclipse.stem.core/model/core.genmodel#//scenario ../../org.eclipse.stem.core/model/core.genmodel#//sequencer ../../org.eclipse.stem.core/model/core.genmodel#//solver ../../org.eclipse.stem.core/model/core.genmodel#//logger">
   <foreignModel>edges.ecore</foreignModel>
   <foreignModel>labels.ecore</foreignModel>
   <foreignModel>nodes.ecore</foreignModel>
@@ -128,6 +127,18 @@
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute labels.ecore#//EarthScienceLabelValue/range"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute labels.ecore#//EarthScienceLabelValue/validYear"/>
     </genClasses>
+    <genClasses ecoreClass="labels.ecore#//GenericLabelValue">
+      <genTypeParameters ecoreTypeParameter="labels.ecore#//GenericLabelValue/T"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute labels.ecore#//GenericLabelValue/value"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute labels.ecore#//GenericLabelValue/unit"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute labels.ecore#//GenericLabelValue/measure"/>
+      <genOperations ecoreOperation="labels.ecore#//GenericLabelValue/getJavaTypeClass"/>
+    </genClasses>
+    <genClasses ecoreClass="labels.ecore#//DoubleLabelValue"/>
+    <genClasses ecoreClass="labels.ecore#//IntegerLabelValue"/>
+    <genClasses ecoreClass="labels.ecore#//LongLabelValue"/>
+    <genClasses ecoreClass="labels.ecore#//StringLabelValue"/>
+    <genClasses ecoreClass="labels.ecore#//KeyValueLabelValue"/>
   </genPackages>
   <genPackages prefix="Nodes" basePackage="org.eclipse.stem.definitions" disposableProviderFactory="true"
       generateExampleClass="false" multipleEditorPages="false" generateModelWizard="false"
diff --git a/core/org.eclipse.stem.definitions/model/labels.ecore b/core/org.eclipse.stem.definitions/model/labels.ecore
index 33b8c9d..a3a6559 100644
--- a/core/org.eclipse.stem.definitions/model/labels.ecore
+++ b/core/org.eclipse.stem.definitions/model/labels.ecore
@@ -126,4 +126,45 @@
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="validYear" eType="ecore:EDataType platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EInt"
         defaultValueLiteral="0"/>
   </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="GenericLabelValue" eSuperTypes="../../org.eclipse.stem.core/model/graph.ecore#//LabelValue">
+    <eTypeParameters name="T"/>
+    <eOperations name="getJavaTypeClass">
+      <eGenericType eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value">
+      <eGenericType eTypeParameter="#//GenericLabelValue/T"/>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="unit" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="measure" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="DoubleLabelValue">
+    <eGenericSuperTypes eClassifier="#//GenericLabelValue">
+      <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDoubleObject"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="IntegerLabelValue">
+    <eGenericSuperTypes eClassifier="#//GenericLabelValue">
+      <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EIntegerObject"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="LongLabelValue">
+    <eGenericSuperTypes eClassifier="#//GenericLabelValue">
+      <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//ELongObject"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="StringLabelValue">
+    <eGenericSuperTypes eClassifier="#//GenericLabelValue">
+      <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    </eGenericSuperTypes>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="KeyValueLabelValue">
+    <eGenericSuperTypes eClassifier="#//GenericLabelValue">
+      <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EMap">
+        <eTypeArguments eClassifier="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+        <eTypeArguments/>
+      </eTypeArguments>
+    </eGenericSuperTypes>
+  </eClassifiers>
 </ecore:EPackage>
diff --git a/core/org.eclipse.stem.definitions/plugin.properties b/core/org.eclipse.stem.definitions/plugin.properties
index 584f8c7..7a282d9 100644
--- a/core/org.eclipse.stem.definitions/plugin.properties
+++ b/core/org.eclipse.stem.definitions/plugin.properties
Binary files differ
diff --git a/core/org.eclipse.stem.definitions/plugin.xml b/core/org.eclipse.stem.definitions/plugin.xml
index ba8014d..6733e6b 100644
--- a/core/org.eclipse.stem.definitions/plugin.xml
+++ b/core/org.eclipse.stem.definitions/plugin.xml
@@ -46,6 +46,19 @@
                org.eclipse.emf.edit.provider.IItemPropertySource"/>
    </extension>
 
+   <extension point="org.eclipse.emf.edit.itemProviderAdapterFactories">
+      <!-- @generated definitions -->
+      <factory
+            uri="http:///org/eclipse/stem/definitions/types.ecore"
+            class="org.eclipse.stem.definitions.types.provider.TypesItemProviderAdapterFactory"
+            supportedTypes=
+              "org.eclipse.emf.edit.provider.IEditingDomainItemProvider
+               org.eclipse.emf.edit.provider.IStructuredItemContentProvider
+               org.eclipse.emf.edit.provider.ITreeItemContentProvider
+               org.eclipse.emf.edit.provider.IItemLabelProvider
+               org.eclipse.emf.edit.provider.IItemPropertySource"/>
+   </extension>
+
    <extension point="org.eclipse.emf.ecore.generated_package">
       <package
             uri="http:///org/eclipse/stem/definitions/edges.ecore"
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdge.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdge.java
index 84193ac..9eac599 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdge.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdge.java
@@ -14,10 +14,10 @@
  *
  * <p>
  * The following features are supported:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.MixingEdge#isUseAbsoluteValues <em>Use Absolute Values</em>}</li>
  * </ul>
- * </p>
  *
  * @see org.eclipse.stem.definitions.edges.EdgesPackage#getMixingEdge()
  * @model
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdgeLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdgeLabelValue.java
index 9c3ce3d..55e44bd 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdgeLabelValue.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/MixingEdgeLabelValue.java
@@ -15,10 +15,10 @@
  *
  * <p>
  * The following features are supported:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.MixingEdgeLabelValue#getMixingRate <em>Mixing Rate</em>}</li>
  * </ul>
- * </p>
  *
  * @see org.eclipse.stem.definitions.edges.EdgesPackage#getMixingEdgeLabelValue()
  * @model
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/PopulationEdge.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/PopulationEdge.java
index 817c4df..9ac6bb6 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/PopulationEdge.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/PopulationEdge.java
@@ -19,10 +19,10 @@
  *
  * <p>
  * The following features are supported:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.PopulationEdge#getPopulationIdentifier <em>Population Identifier</em>}</li>
  * </ul>
- * </p>
  *
  * @see org.eclipse.stem.definitions.edges.EdgesPackage#getPopulationEdge()
  * @model
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/EdgesFactoryImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/EdgesFactoryImpl.java
index 05c6759..6595fb0 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/EdgesFactoryImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/EdgesFactoryImpl.java
@@ -16,6 +16,7 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.stem.definitions.edges.*;
 import org.eclipse.stem.definitions.edges.EdgesFactory;
 import org.eclipse.stem.definitions.edges.EdgesPackage;
 import org.eclipse.stem.definitions.edges.MigrationEdge;
@@ -41,7 +42,7 @@
 	 */
 	public static EdgesFactory init() {
 		try {
-			EdgesFactory theEdgesFactory = (EdgesFactory)EPackage.Registry.INSTANCE.getEFactory("http:///org/eclipse/stem/definitions/edges.ecore"); //$NON-NLS-1$ 
+			EdgesFactory theEdgesFactory = (EdgesFactory)EPackage.Registry.INSTANCE.getEFactory(EdgesPackage.eNS_URI);
 			if (theEdgesFactory != null) {
 				return theEdgesFactory;
 			}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeImpl.java
index 615cc3d..6e920b3 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeImpl.java
@@ -26,10 +26,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.impl.MigrationEdgeImpl#isUseAbsoluteValues <em>Use Absolute Values</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelImpl.java
index adae48c..3f34659 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelImpl.java
@@ -29,8 +29,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model object '<em><b>Migration Edge Label</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelValueImpl.java
index 0ce430c..a3dcdf1 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MigrationEdgeLabelValueImpl.java
@@ -24,11 +24,11 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.impl.MigrationEdgeLabelValueImpl#getMigrationRate <em>Migration Rate</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.edges.impl.MigrationEdgeLabelValueImpl#getTimePeriod <em>Time Period</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeImpl.java
index 3ab9bd3..e3873c8 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeImpl.java
@@ -21,11 +21,11 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.impl.MixingEdgeImpl#isUseAbsoluteValues <em>Use Absolute Values</em>}</li>
  * </ul>
- * </p>
- * 
+ *
  * @generated
  */
 public class MixingEdgeImpl extends PopulationEdgeImpl implements MixingEdge {
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelImpl.java
index 0637292..ba13883 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelImpl.java
@@ -24,8 +24,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model object '<em><b>Mixing Edge Label</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelValueImpl.java
index 708e8a3..e504f5a 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/MixingEdgeLabelValueImpl.java
@@ -19,10 +19,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.impl.MixingEdgeLabelValueImpl#getMixingRate <em>Mixing Rate</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/PopulationEdgeImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/PopulationEdgeImpl.java
index 341f951..a9dd7ee 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/PopulationEdgeImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/impl/PopulationEdgeImpl.java
@@ -24,10 +24,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.edges.impl.PopulationEdgeImpl#getPopulationIdentifier <em>Population Identifier</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesActionBarContributor.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesActionBarContributor.java
index e93cd88..471429d 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesActionBarContributor.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesActionBarContributor.java
@@ -206,8 +206,7 @@
 		//
 		submenuManager.addMenuListener
 			(new IMenuListener() {
-				 @Override
-				public void menuAboutToShow(IMenuManager menuManager) {
+				 public void menuAboutToShow(IMenuManager menuManager) {
 					 menuManager.updateAll(true);
 				 }
 			 });
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesEditor.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesEditor.java
index 66ac52b..45db06a 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesEditor.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/presentation/EdgesEditor.java
@@ -80,6 +80,7 @@
 import org.eclipse.jface.action.Separator;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.util.LocalSelectionTransfer;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.ISelectionChangedListener;
 import org.eclipse.jface.viewers.ISelectionProvider;
@@ -105,6 +106,7 @@
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.FileTransfer;
 import org.eclipse.swt.dnd.Transfer;
 import org.eclipse.swt.events.ControlAdapter;
 import org.eclipse.swt.events.ControlEvent;
@@ -187,7 +189,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	protected PropertySheetPage propertySheetPage;
+	protected List<PropertySheetPage> propertySheetPages = new ArrayList<PropertySheetPage>();
 
 	/**
 	 * This is the viewer that shadows the selection in the content outline.
@@ -247,7 +249,6 @@
 	 */
 	protected IPartListener partListener =
 		new IPartListener() {
-			@Override
 			public void partActivated(IWorkbenchPart p) {
 				if (p instanceof ContentOutline) {
 					if (((ContentOutline)p).getCurrentPage() == contentOutlinePage) {
@@ -257,7 +258,7 @@
 					}
 				}
 				else if (p instanceof PropertySheet) {
-					if (((PropertySheet)p).getCurrentPage() == propertySheetPage) {
+					if (propertySheetPages.contains(((PropertySheet)p).getCurrentPage())) {
 						getActionBarContributor().setActiveEditor(EdgesEditor.this);
 						handleActivate();
 					}
@@ -266,19 +267,15 @@
 					handleActivate();
 				}
 			}
-			@Override
 			public void partBroughtToTop(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partClosed(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partDeactivated(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partOpened(IWorkbenchPart p) {
 				// Ignore.
 			}
@@ -351,8 +348,7 @@
 							if (updateProblemIndication) {
 								getSite().getShell().getDisplay().asyncExec
 									(new Runnable() {
-										 @Override
-										public void run() {
+										 public void run() {
 											 updateProblemIndication();
 										 }
 									 });
@@ -374,6 +370,15 @@
 			@Override
 			protected void unsetTarget(Resource target) {
 				basicUnsetTarget(target);
+				resourceToDiagnosticMap.remove(target);
+				if (updateProblemIndication) {
+					getSite().getShell().getDisplay().asyncExec
+						(new Runnable() {
+							 public void run() {
+								 updateProblemIndication();
+							 }
+						 });
+				}
 			}
 		};
 
@@ -385,7 +390,6 @@
 	 */
 	protected IResourceChangeListener resourceChangeListener =
 		new IResourceChangeListener() {
-			@Override
 			public void resourceChanged(IResourceChangeEvent event) {
 				IResourceDelta delta = event.getDelta();
 				try {
@@ -394,7 +398,6 @@
 						protected Collection<Resource> changedResources = new ArrayList<Resource>();
 						protected Collection<Resource> removedResources = new ArrayList<Resource>();
 
-						@Override
 						public boolean visit(IResourceDelta delta) {
 							if (delta.getResource().getType() == IResource.FILE) {
 								if (delta.getKind() == IResourceDelta.REMOVED ||
@@ -409,6 +412,7 @@
 										}
 									}
 								}
+								return false;
 							}
 
 							return true;
@@ -429,8 +433,7 @@
 					if (!visitor.getRemovedResources().isEmpty()) {
 						getSite().getShell().getDisplay().asyncExec
 							(new Runnable() {
-								 @Override
-								public void run() {
+								 public void run() {
 									 removedResources.addAll(visitor.getRemovedResources());
 									 if (!isDirty()) {
 										 getSite().getPage().closeEditor(EdgesEditor.this, false);
@@ -442,8 +445,7 @@
 					if (!visitor.getChangedResources().isEmpty()) {
 						getSite().getShell().getDisplay().asyncExec
 							(new Runnable() {
-								 @Override
-								public void run() {
+								 public void run() {
 									 changedResources.addAll(visitor.getChangedResources());
 									 if (getSite().getPage().getActiveEditor() == EdgesEditor.this) {
 										 handleActivate();
@@ -647,12 +649,10 @@
 		//
 		commandStack.addCommandStackListener
 			(new CommandStackListener() {
-				 @Override
-				public void commandStackChanged(final EventObject event) {
+				 public void commandStackChanged(final EventObject event) {
 					 getContainer().getDisplay().asyncExec
 						 (new Runnable() {
-							  @Override
-							public void run() {
+							  public void run() {
 								  firePropertyChange(IEditorPart.PROP_DIRTY);
 
 								  // Try to select the affected objects.
@@ -661,8 +661,14 @@
 								  if (mostRecentCommand != null) {
 									  setSelectionToViewer(mostRecentCommand.getAffectedObjects());
 								  }
-								  if (propertySheetPage != null && !propertySheetPage.getControl().isDisposed()) {
-									  propertySheetPage.refresh();
+								  for (Iterator<PropertySheetPage> i = propertySheetPages.iterator(); i.hasNext(); ) {
+									  PropertySheetPage propertySheetPage = i.next();
+									  if (propertySheetPage.getControl().isDisposed()) {
+										  i.remove();
+									  }
+									  else {
+										  propertySheetPage.refresh();
+									  }
 								  }
 							  }
 						  });
@@ -698,7 +704,6 @@
 		if (theSelection != null && !theSelection.isEmpty()) {
 			Runnable runnable =
 				new Runnable() {
-					@Override
 					public void run() {
 						// Try to select the items in the current content viewer of the editor.
 						//
@@ -801,7 +806,6 @@
 					new ISelectionChangedListener() {
 						// This just notifies those things that are affected by the section.
 						//
-						@Override
 						public void selectionChanged(SelectionChangedEvent selectionChangedEvent) {
 							setSelection(selectionChangedEvent.getSelection());
 						}
@@ -857,7 +861,7 @@
 		getSite().registerContextMenu(contextMenu, new UnwrappingSelectionProvider(viewer));
 
 		int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
-		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() };
+		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance(), LocalSelectionTransfer.getTransfer(), FileTransfer.getInstance() };
 		viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(viewer));
 		viewer.addDropSupport(dndOperations, transfers, new EditingDomainViewerDropAdapter(editingDomain, viewer));
 	}
@@ -897,10 +901,11 @@
 	 * @generated
 	 */
 	public Diagnostic analyzeResourceProblems(Resource resource, Exception exception) {
-		if (!resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty()) {
+		boolean hasErrors = !resource.getErrors().isEmpty();
+		if (hasErrors || !resource.getWarnings().isEmpty()) {
 			BasicDiagnostic basicDiagnostic =
 				new BasicDiagnostic
-					(Diagnostic.ERROR,
+					(hasErrors ? Diagnostic.ERROR : Diagnostic.WARNING,
 					 "org.eclipse.stem.definitions", //$NON-NLS-1$
 					 0,
 					 getString("_UI_CreateModelError_message", resource.getURI()), //$NON-NLS-1$
@@ -956,8 +961,7 @@
 
 			getSite().getShell().getDisplay().asyncExec
 				(new Runnable() {
-					 @Override
-					public void run() {
+					 public void run() {
 						 setActivePage(0);
 					 }
 				 });
@@ -981,8 +985,7 @@
 
 		getSite().getShell().getDisplay().asyncExec
 			(new Runnable() {
-				 @Override
-				public void run() {
+				 public void run() {
 					 updateProblemIndication();
 				 }
 			 });
@@ -1117,8 +1120,7 @@
 				(new ISelectionChangedListener() {
 					 // This ensures that we handle selections correctly.
 					 //
-					 @Override
-					public void selectionChanged(SelectionChangedEvent event) {
+					 public void selectionChanged(SelectionChangedEvent event) {
 						 handleContentOutlineSelection(event.getSelection());
 					 }
 				 });
@@ -1134,23 +1136,22 @@
 	 * @generated
 	 */
 	public IPropertySheetPage getPropertySheetPage() {
-		if (propertySheetPage == null) {
-			propertySheetPage =
-				new ExtendedPropertySheetPage(editingDomain) {
-					@Override
-					public void setSelectionToViewer(List<?> selection) {
-						EdgesEditor.this.setSelectionToViewer(selection);
-						EdgesEditor.this.setFocus();
-					}
+		PropertySheetPage propertySheetPage =
+			new ExtendedPropertySheetPage(editingDomain) {
+				@Override
+				public void setSelectionToViewer(List<?> selection) {
+					EdgesEditor.this.setSelectionToViewer(selection);
+					EdgesEditor.this.setFocus();
+				}
 
-					@Override
-					public void setActionBars(IActionBars actionBars) {
-						super.setActionBars(actionBars);
-						getActionBarContributor().shareGlobalActions(this, actionBars);
-					}
-				};
-			propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
-		}
+				@Override
+				public void setActionBars(IActionBars actionBars) {
+					super.setActionBars(actionBars);
+					getActionBarContributor().shareGlobalActions(this, actionBars);
+				}
+			};
+		propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
+		propertySheetPages.add(propertySheetPage);
 
 		return propertySheetPage;
 	}
@@ -1205,6 +1206,7 @@
 		//
 		final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
 		saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
+		saveOptions.put(Resource.OPTION_LINE_DELIMITER, Resource.OPTION_LINE_DELIMITER_UNSPECIFIED);
 
 		// Do the work within an operation because this is a long running activity that modifies the workbench.
 		//
@@ -1257,7 +1259,7 @@
 
 	/**
 	 * This returns whether something has been persisted to the URI of the specified resource.
-	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream. 
+	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -1330,20 +1332,9 @@
 	 */
 	@Override
 	public void gotoMarker(IMarker marker) {
-		try {
-			if (marker.getType().equals(EValidator.MARKER)) {
-				String uriAttribute = marker.getAttribute(EValidator.URI_ATTRIBUTE, null);
-				if (uriAttribute != null) {
-					URI uri = URI.createURI(uriAttribute);
-					EObject eObject = editingDomain.getResourceSet().getEObject(uri, true);
-					if (eObject != null) {
-					  setSelectionToViewer(Collections.singleton(editingDomain.getWrapper(eObject)));
-					}
-				}
-			}
-		}
-		catch (CoreException exception) {
-			DefinitionsEditPlugin.INSTANCE.log(exception);
+		List<?> targetObjects = markerHelper.getTargetObjects(editingDomain, marker);
+		if (!targetObjects.isEmpty()) {
+			setSelectionToViewer(targetObjects);
 		}
 	}
 
@@ -1534,7 +1525,7 @@
 			getActionBarContributor().setActiveEditor(null);
 		}
 
-		if (propertySheetPage != null) {
+		for (PropertySheetPage propertySheetPage : propertySheetPages) {
 			propertySheetPage.dispose();
 		}
 
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeItemProvider.java
index f48fb4c..2886e32 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeItemProvider.java
@@ -37,13 +37,7 @@
  * @generated
  */
 public class MigrationEdgeItemProvider
-	extends PopulationEdgeItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends PopulationEdgeItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelItemProvider.java
index 39b0508..04d91fe 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelItemProvider.java
@@ -37,13 +37,7 @@
  * @generated
  */
 public class MigrationEdgeLabelItemProvider
-	extends EdgeLabelItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends EdgeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelValueItemProvider.java
index 759a264..a070609 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MigrationEdgeLabelValueItemProvider.java
@@ -38,13 +38,7 @@
  * @generated
  */
 public class MigrationEdgeLabelValueItemProvider
-	extends LabelValueItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeItemProvider.java
index fcfed9f..fbf4cea 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeItemProvider.java
@@ -12,6 +12,7 @@
 
 import org.eclipse.emf.common.notify.AdapterFactory;
 import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
 import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
 import org.eclipse.emf.edit.provider.IItemLabelProvider;
@@ -31,13 +32,7 @@
  * @generated
  */
 public class MixingEdgeItemProvider
-	extends PopulationEdgeItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends PopulationEdgeItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelItemProvider.java
index 0b464be..be26309 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelItemProvider.java
@@ -13,6 +13,7 @@
 import org.eclipse.emf.common.notify.AdapterFactory;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.util.ResourceLocator;
+import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
 import org.eclipse.emf.edit.provider.IItemLabelProvider;
 import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
@@ -22,6 +23,7 @@
 import org.eclipse.stem.core.graph.Edge;
 import org.eclipse.stem.core.graph.EdgeLabel;
 import org.eclipse.stem.core.graph.provider.EdgeLabelItemProvider;
+import org.eclipse.stem.definitions.edges.MixingEdgeLabel;
 import org.eclipse.stem.geography.names.GeographicNames;
 
 /**
@@ -31,13 +33,7 @@
  * @generated
  */
 public class MixingEdgeLabelItemProvider
-	extends EdgeLabelItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends EdgeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelValueItemProvider.java
index 23bc185..b80fbe1 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/MixingEdgeLabelValueItemProvider.java
@@ -33,13 +33,7 @@
  * @generated
  */
 public class MixingEdgeLabelValueItemProvider
-	extends LabelValueItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/PopulationEdgeItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/PopulationEdgeItemProvider.java
index 8634208..efe9eec 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/PopulationEdgeItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/provider/PopulationEdgeItemProvider.java
@@ -41,13 +41,7 @@
  * @generated
  */
 public class PopulationEdgeItemProvider
-	extends EdgeItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends EdgeItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesAdapterFactory.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesAdapterFactory.java
index a4e4f4f..71d4468 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesAdapterFactory.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesAdapterFactory.java
@@ -22,6 +22,7 @@
 import org.eclipse.stem.core.graph.Label;
 import org.eclipse.stem.core.graph.LabelValue;
 import org.eclipse.stem.core.modifier.Modifiable;
+import org.eclipse.stem.definitions.edges.*;
 import org.eclipse.stem.definitions.edges.EdgesPackage;
 import org.eclipse.stem.definitions.edges.MigrationEdge;
 import org.eclipse.stem.definitions.edges.MigrationEdgeLabel;
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesSwitch.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesSwitch.java
index 8b19fe6..748b733 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesSwitch.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/edges/util/EdgesSwitch.java
@@ -15,6 +15,8 @@
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
 import org.eclipse.stem.core.common.Identifiable;
 import org.eclipse.stem.core.common.SanityChecker;
 import org.eclipse.stem.core.graph.Edge;
@@ -22,6 +24,7 @@
 import org.eclipse.stem.core.graph.Label;
 import org.eclipse.stem.core.graph.LabelValue;
 import org.eclipse.stem.core.modifier.Modifiable;
+import org.eclipse.stem.definitions.edges.*;
 import org.eclipse.stem.definitions.edges.EdgesPackage;
 import org.eclipse.stem.definitions.edges.MigrationEdge;
 import org.eclipse.stem.definitions.edges.MigrationEdgeLabel;
@@ -44,7 +47,7 @@
  * @see org.eclipse.stem.definitions.edges.EdgesPackage
  * @generated
  */
-public class EdgesSwitch<T1> {
+public class EdgesSwitch<T1> extends Switch<T1> {
 	/**
 	 * The cached model package
 	 * <!-- begin-user-doc -->
@@ -66,14 +69,16 @@
 	}
 
 	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * Checks whether this is a switch for the given package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @param ePackage the package in question.
+	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
-	public T1 doSwitch(EObject theEObject) {
-		return doSwitch(theEObject.eClass(), theEObject);
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
 	}
 
 	/**
@@ -83,26 +88,7 @@
 	 * @return the first non-null result returned by a <code>caseXXX</code> call.
 	 * @generated
 	 */
-	protected T1 doSwitch(EClass theEClass, EObject theEObject) {
-		if (theEClass.eContainer() == modelPackage) {
-			return doSwitch(theEClass.getClassifierID(), theEObject);
-		}
-		else {
-			List<EClass> eSuperTypes = theEClass.getESuperTypes();
-			return
-				eSuperTypes.isEmpty() ?
-					defaultCase(theEObject) :
-					doSwitch(eSuperTypes.get(0), theEObject);
-		}
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
+	@Override
 	protected T1 doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
 			case EdgesPackage.MIGRATION_EDGE: {
@@ -420,6 +406,7 @@
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
 	 */
+	@Override
 	public T1 defaultCase(EObject object) {
 		return null;
 	}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/DoubleLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/DoubleLabelValue.java
new file mode 100644
index 0000000..94a9d60
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/DoubleLabelValue.java
@@ -0,0 +1,17 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Double Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.stem.definitions.labels.LabelsPackage#getDoubleLabelValue()
+ * @model superTypes="org.eclipse.stem.definitions.labels.GenericLabelValue<org.eclipse.emf.ecore.EDoubleObject>"
+ * @generated
+ */
+public interface DoubleLabelValue extends GenericLabelValue<Double> {
+} // DoubleLabelValue
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabel.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabel.java
index 0565d80..3cbe146 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabel.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabel.java
@@ -21,10 +21,10 @@
  *
  * <p>
  * The following features are supported:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.EarthScienceLabel#getCurrentEarthScienceValue <em>Current Earth Science Value</em>}</li>
  * </ul>
- * </p>
  *
  * @see org.eclipse.stem.definitions.labels.LabelsPackage#getEarthScienceLabel()
  * @model
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabelValue.java
index 1b8c984..aadc8bb 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabelValue.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/EarthScienceLabelValue.java
@@ -20,6 +20,7 @@
  *
  * <p>
  * The following features are supported:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.EarthScienceLabelValue#getDataType <em>Data Type</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.EarthScienceLabelValue#getUnits <em>Units</em>}</li>
@@ -35,7 +36,6 @@
  *   <li>{@link org.eclipse.stem.definitions.labels.EarthScienceLabelValue#getRange <em>Range</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.EarthScienceLabelValue#getValidYear <em>Valid Year</em>}</li>
  * </ul>
- * </p>
  *
  * @see org.eclipse.stem.definitions.labels.LabelsPackage#getEarthScienceLabelValue()
  * @model
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/GenericLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/GenericLabelValue.java
new file mode 100644
index 0000000..98c8851
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/GenericLabelValue.java
@@ -0,0 +1,112 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels;
+
+import org.eclipse.stem.core.graph.LabelValue;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Generic Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getUnit <em>Unit</em>}</li>
+ *   <li>{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getMeasure <em>Measure</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.stem.definitions.labels.LabelsPackage#getGenericLabelValue()
+ * @model
+ * @generated
+ */
+public interface GenericLabelValue<T> extends LabelValue {
+	/**
+	 * Returns the value of the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Value</em>' attribute.
+	 * @see #setValue(Object)
+	 * @see org.eclipse.stem.definitions.labels.LabelsPackage#getGenericLabelValue_Value()
+	 * @model
+	 * @generated
+	 */
+	T getValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getValue <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Value</em>' attribute.
+	 * @see #getValue()
+	 * @generated
+	 */
+	void setValue(T value);
+
+	/**
+	 * Returns the value of the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Unit</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Unit</em>' attribute.
+	 * @see #setUnit(String)
+	 * @see org.eclipse.stem.definitions.labels.LabelsPackage#getGenericLabelValue_Unit()
+	 * @model
+	 * @generated
+	 */
+	String getUnit();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getUnit <em>Unit</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Unit</em>' attribute.
+	 * @see #getUnit()
+	 * @generated
+	 */
+	void setUnit(String value);
+
+	/**
+	 * Returns the value of the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Measure</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Measure</em>' attribute.
+	 * @see #setMeasure(String)
+	 * @see org.eclipse.stem.definitions.labels.LabelsPackage#getGenericLabelValue_Measure()
+	 * @model
+	 * @generated
+	 */
+	String getMeasure();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getMeasure <em>Measure</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Measure</em>' attribute.
+	 * @see #getMeasure()
+	 * @generated
+	 */
+	void setMeasure(String value);
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @model kind="operation"
+	 * @generated
+	 */
+	Class<?> getJavaTypeClass();
+
+} // GenericLabelValue
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/IntegerLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/IntegerLabelValue.java
new file mode 100644
index 0000000..35fd3a1
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/IntegerLabelValue.java
@@ -0,0 +1,17 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Integer Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.stem.definitions.labels.LabelsPackage#getIntegerLabelValue()
+ * @model superTypes="org.eclipse.stem.definitions.labels.GenericLabelValue<org.eclipse.emf.ecore.EIntegerObject>"
+ * @generated
+ */
+public interface IntegerLabelValue extends GenericLabelValue<Integer> {
+} // IntegerLabelValue
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/KeyValueLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/KeyValueLabelValue.java
new file mode 100644
index 0000000..5b4cdb6
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/KeyValueLabelValue.java
@@ -0,0 +1,18 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels;
+
+import java.util.Map;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Key Value Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.stem.definitions.labels.LabelsPackage#getKeyValueLabelValue()
+ * @model superTypes="org.eclipse.stem.definitions.labels.GenericLabelValue<org.eclipse.emf.ecore.EMap<org.eclipse.emf.ecore.EString, org.eclipse.emf.ecore.EJavaObject>>"
+ * @generated
+ */
+public interface KeyValueLabelValue extends GenericLabelValue<Map<String, Object>> {
+} // KeyValueLabelValue
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsFactory.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsFactory.java
index c880aac..27a0890 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsFactory.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsFactory.java
@@ -166,6 +166,60 @@
 	EarthScienceLabelValue createEarthScienceLabelValue();
 
 	/**
+	 * Returns a new object of class '<em>Generic Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Generic Label Value</em>'.
+	 * @generated
+	 */
+	<T> GenericLabelValue<T> createGenericLabelValue();
+
+	/**
+	 * Returns a new object of class '<em>Double Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Double Label Value</em>'.
+	 * @generated
+	 */
+	DoubleLabelValue createDoubleLabelValue();
+
+	/**
+	 * Returns a new object of class '<em>Integer Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Integer Label Value</em>'.
+	 * @generated
+	 */
+	IntegerLabelValue createIntegerLabelValue();
+
+	/**
+	 * Returns a new object of class '<em>Long Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Long Label Value</em>'.
+	 * @generated
+	 */
+	LongLabelValue createLongLabelValue();
+
+	/**
+	 * Returns a new object of class '<em>String Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>String Label Value</em>'.
+	 * @generated
+	 */
+	StringLabelValue createStringLabelValue();
+
+	/**
+	 * Returns a new object of class '<em>Key Value Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Key Value Label Value</em>'.
+	 * @generated
+	 */
+	KeyValueLabelValue createKeyValueLabelValue();
+
+	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsPackage.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsPackage.java
index 7281f34..d2bbc1f 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsPackage.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LabelsPackage.java
@@ -1271,6 +1271,282 @@
 	int EARTH_SCIENCE_LABEL_VALUE_FEATURE_COUNT = GraphPackage.LABEL_VALUE_FEATURE_COUNT + 13;
 
 	/**
+	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl <em>Generic Label Value</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl
+	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getGenericLabelValue()
+	 * @generated
+	 */
+	int GENERIC_LABEL_VALUE = 16;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GENERIC_LABEL_VALUE__VALUE = GraphPackage.LABEL_VALUE_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GENERIC_LABEL_VALUE__UNIT = GraphPackage.LABEL_VALUE_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GENERIC_LABEL_VALUE__MEASURE = GraphPackage.LABEL_VALUE_FEATURE_COUNT + 2;
+
+	/**
+	 * The number of structural features of the '<em>Generic Label Value</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int GENERIC_LABEL_VALUE_FEATURE_COUNT = GraphPackage.LABEL_VALUE_FEATURE_COUNT + 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.impl.DoubleLabelValueImpl <em>Double Label Value</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.stem.definitions.labels.impl.DoubleLabelValueImpl
+	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getDoubleLabelValue()
+	 * @generated
+	 */
+	int DOUBLE_LABEL_VALUE = 17;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LABEL_VALUE__VALUE = GENERIC_LABEL_VALUE__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LABEL_VALUE__UNIT = GENERIC_LABEL_VALUE__UNIT;
+
+	/**
+	 * The feature id for the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LABEL_VALUE__MEASURE = GENERIC_LABEL_VALUE__MEASURE;
+
+	/**
+	 * The number of structural features of the '<em>Double Label Value</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int DOUBLE_LABEL_VALUE_FEATURE_COUNT = GENERIC_LABEL_VALUE_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.impl.IntegerLabelValueImpl <em>Integer Label Value</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.stem.definitions.labels.impl.IntegerLabelValueImpl
+	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getIntegerLabelValue()
+	 * @generated
+	 */
+	int INTEGER_LABEL_VALUE = 18;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int INTEGER_LABEL_VALUE__VALUE = GENERIC_LABEL_VALUE__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int INTEGER_LABEL_VALUE__UNIT = GENERIC_LABEL_VALUE__UNIT;
+
+	/**
+	 * The feature id for the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int INTEGER_LABEL_VALUE__MEASURE = GENERIC_LABEL_VALUE__MEASURE;
+
+	/**
+	 * The number of structural features of the '<em>Integer Label Value</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int INTEGER_LABEL_VALUE_FEATURE_COUNT = GENERIC_LABEL_VALUE_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.impl.LongLabelValueImpl <em>Long Label Value</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.stem.definitions.labels.impl.LongLabelValueImpl
+	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getLongLabelValue()
+	 * @generated
+	 */
+	int LONG_LABEL_VALUE = 19;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LONG_LABEL_VALUE__VALUE = GENERIC_LABEL_VALUE__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LONG_LABEL_VALUE__UNIT = GENERIC_LABEL_VALUE__UNIT;
+
+	/**
+	 * The feature id for the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LONG_LABEL_VALUE__MEASURE = GENERIC_LABEL_VALUE__MEASURE;
+
+	/**
+	 * The number of structural features of the '<em>Long Label Value</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LONG_LABEL_VALUE_FEATURE_COUNT = GENERIC_LABEL_VALUE_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.impl.StringLabelValueImpl <em>String Label Value</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.stem.definitions.labels.impl.StringLabelValueImpl
+	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getStringLabelValue()
+	 * @generated
+	 */
+	int STRING_LABEL_VALUE = 20;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LABEL_VALUE__VALUE = GENERIC_LABEL_VALUE__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LABEL_VALUE__UNIT = GENERIC_LABEL_VALUE__UNIT;
+
+	/**
+	 * The feature id for the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LABEL_VALUE__MEASURE = GENERIC_LABEL_VALUE__MEASURE;
+
+	/**
+	 * The number of structural features of the '<em>String Label Value</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int STRING_LABEL_VALUE_FEATURE_COUNT = GENERIC_LABEL_VALUE_FEATURE_COUNT + 0;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.impl.KeyValueLabelValueImpl <em>Key Value Label Value</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.stem.definitions.labels.impl.KeyValueLabelValueImpl
+	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getKeyValueLabelValue()
+	 * @generated
+	 */
+	int KEY_VALUE_LABEL_VALUE = 21;
+
+	/**
+	 * The feature id for the '<em><b>Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int KEY_VALUE_LABEL_VALUE__VALUE = GENERIC_LABEL_VALUE__VALUE;
+
+	/**
+	 * The feature id for the '<em><b>Unit</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int KEY_VALUE_LABEL_VALUE__UNIT = GENERIC_LABEL_VALUE__UNIT;
+
+	/**
+	 * The feature id for the '<em><b>Measure</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int KEY_VALUE_LABEL_VALUE__MEASURE = GENERIC_LABEL_VALUE__MEASURE;
+
+	/**
+	 * The number of structural features of the '<em>Key Value Label Value</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int KEY_VALUE_LABEL_VALUE_FEATURE_COUNT = GENERIC_LABEL_VALUE_FEATURE_COUNT + 0;
+
+	/**
 	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.RelativePhysicalRelationship <em>Relative Physical Relationship</em>}' enum.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1278,7 +1554,7 @@
 	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getRelativePhysicalRelationship()
 	 * @generated
 	 */
-	int RELATIVE_PHYSICAL_RELATIONSHIP = 16;
+	int RELATIVE_PHYSICAL_RELATIONSHIP = 22;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.stem.definitions.labels.TransportMode <em>Transport Mode</em>}' enum.
@@ -1288,7 +1564,7 @@
 	 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getTransportMode()
 	 * @generated
 	 */
-	int TRANSPORT_MODE = 17;
+	int TRANSPORT_MODE = 23;
 
 
 	/**
@@ -1903,6 +2179,99 @@
 	EAttribute getEarthScienceLabelValue_ValidYear();
 
 	/**
+	 * Returns the meta object for class '{@link org.eclipse.stem.definitions.labels.GenericLabelValue <em>Generic Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Generic Label Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.GenericLabelValue
+	 * @generated
+	 */
+	EClass getGenericLabelValue();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getValue <em>Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.GenericLabelValue#getValue()
+	 * @see #getGenericLabelValue()
+	 * @generated
+	 */
+	EAttribute getGenericLabelValue_Value();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getUnit <em>Unit</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Unit</em>'.
+	 * @see org.eclipse.stem.definitions.labels.GenericLabelValue#getUnit()
+	 * @see #getGenericLabelValue()
+	 * @generated
+	 */
+	EAttribute getGenericLabelValue_Unit();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.stem.definitions.labels.GenericLabelValue#getMeasure <em>Measure</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Measure</em>'.
+	 * @see org.eclipse.stem.definitions.labels.GenericLabelValue#getMeasure()
+	 * @see #getGenericLabelValue()
+	 * @generated
+	 */
+	EAttribute getGenericLabelValue_Measure();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.stem.definitions.labels.DoubleLabelValue <em>Double Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Double Label Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.DoubleLabelValue
+	 * @generated
+	 */
+	EClass getDoubleLabelValue();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.stem.definitions.labels.IntegerLabelValue <em>Integer Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Integer Label Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.IntegerLabelValue
+	 * @generated
+	 */
+	EClass getIntegerLabelValue();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.stem.definitions.labels.LongLabelValue <em>Long Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Long Label Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.LongLabelValue
+	 * @generated
+	 */
+	EClass getLongLabelValue();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.stem.definitions.labels.StringLabelValue <em>String Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>String Label Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.StringLabelValue
+	 * @generated
+	 */
+	EClass getStringLabelValue();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.stem.definitions.labels.KeyValueLabelValue <em>Key Value Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Key Value Label Value</em>'.
+	 * @see org.eclipse.stem.definitions.labels.KeyValueLabelValue
+	 * @generated
+	 */
+	EClass getKeyValueLabelValue();
+
+	/**
 	 * Returns the meta object for enum '{@link org.eclipse.stem.definitions.labels.RelativePhysicalRelationship <em>Relative Physical Relationship</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -2433,6 +2802,90 @@
 		EAttribute EARTH_SCIENCE_LABEL_VALUE__VALID_YEAR = eINSTANCE.getEarthScienceLabelValue_ValidYear();
 
 		/**
+		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl <em>Generic Label Value</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl
+		 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getGenericLabelValue()
+		 * @generated
+		 */
+		EClass GENERIC_LABEL_VALUE = eINSTANCE.getGenericLabelValue();
+
+		/**
+		 * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GENERIC_LABEL_VALUE__VALUE = eINSTANCE.getGenericLabelValue_Value();
+
+		/**
+		 * The meta object literal for the '<em><b>Unit</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GENERIC_LABEL_VALUE__UNIT = eINSTANCE.getGenericLabelValue_Unit();
+
+		/**
+		 * The meta object literal for the '<em><b>Measure</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute GENERIC_LABEL_VALUE__MEASURE = eINSTANCE.getGenericLabelValue_Measure();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.impl.DoubleLabelValueImpl <em>Double Label Value</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.stem.definitions.labels.impl.DoubleLabelValueImpl
+		 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getDoubleLabelValue()
+		 * @generated
+		 */
+		EClass DOUBLE_LABEL_VALUE = eINSTANCE.getDoubleLabelValue();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.impl.IntegerLabelValueImpl <em>Integer Label Value</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.stem.definitions.labels.impl.IntegerLabelValueImpl
+		 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getIntegerLabelValue()
+		 * @generated
+		 */
+		EClass INTEGER_LABEL_VALUE = eINSTANCE.getIntegerLabelValue();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.impl.LongLabelValueImpl <em>Long Label Value</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.stem.definitions.labels.impl.LongLabelValueImpl
+		 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getLongLabelValue()
+		 * @generated
+		 */
+		EClass LONG_LABEL_VALUE = eINSTANCE.getLongLabelValue();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.impl.StringLabelValueImpl <em>String Label Value</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.stem.definitions.labels.impl.StringLabelValueImpl
+		 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getStringLabelValue()
+		 * @generated
+		 */
+		EClass STRING_LABEL_VALUE = eINSTANCE.getStringLabelValue();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.impl.KeyValueLabelValueImpl <em>Key Value Label Value</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.stem.definitions.labels.impl.KeyValueLabelValueImpl
+		 * @see org.eclipse.stem.definitions.labels.impl.LabelsPackageImpl#getKeyValueLabelValue()
+		 * @generated
+		 */
+		EClass KEY_VALUE_LABEL_VALUE = eINSTANCE.getKeyValueLabelValue();
+
+		/**
 		 * The meta object literal for the '{@link org.eclipse.stem.definitions.labels.RelativePhysicalRelationship <em>Relative Physical Relationship</em>}' enum.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LongLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LongLabelValue.java
new file mode 100644
index 0000000..4d852d3
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/LongLabelValue.java
@@ -0,0 +1,17 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Long Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.stem.definitions.labels.LabelsPackage#getLongLabelValue()
+ * @model superTypes="org.eclipse.stem.definitions.labels.GenericLabelValue<org.eclipse.emf.ecore.ELongObject>"
+ * @generated
+ */
+public interface LongLabelValue extends GenericLabelValue<Long> {
+} // LongLabelValue
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/RelativePhysicalRelationship.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/RelativePhysicalRelationship.java
index 78cccdf..0438873 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/RelativePhysicalRelationship.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/RelativePhysicalRelationship.java
@@ -265,6 +265,8 @@
 	 * Returns the '<em><b>Relative Physical Relationship</b></em>' literal with the specified literal value.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @param literal the literal.
+	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
 	public static RelativePhysicalRelationship get(String literal) {
@@ -281,6 +283,8 @@
 	 * Returns the '<em><b>Relative Physical Relationship</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @param name the name.
+	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
 	public static RelativePhysicalRelationship getByName(String name) {
@@ -297,6 +301,8 @@
 	 * Returns the '<em><b>Relative Physical Relationship</b></em>' literal with the specified integer value.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @param value the integer value.
+	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
 	public static RelativePhysicalRelationship get(int value) {
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/StringLabelValue.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/StringLabelValue.java
new file mode 100644
index 0000000..5278de4
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/StringLabelValue.java
@@ -0,0 +1,17 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>String Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.stem.definitions.labels.LabelsPackage#getStringLabelValue()
+ * @model superTypes="org.eclipse.stem.definitions.labels.GenericLabelValue<org.eclipse.emf.ecore.EString>"
+ * @generated
+ */
+public interface StringLabelValue extends GenericLabelValue<String> {
+} // StringLabelValue
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/TransportMode.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/TransportMode.java
index c448fd2..0549288 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/TransportMode.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/TransportMode.java
@@ -147,6 +147,8 @@
 	 * Returns the '<em><b>Transport Mode</b></em>' literal with the specified literal value.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @param literal the literal.
+	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
 	public static TransportMode get(String literal) {
@@ -163,6 +165,8 @@
 	 * Returns the '<em><b>Transport Mode</b></em>' literal with the specified name.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @param name the name.
+	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
 	public static TransportMode getByName(String name) {
@@ -179,6 +183,8 @@
 	 * Returns the '<em><b>Transport Mode</b></em>' literal with the specified integer value.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
+	 * @param value the integer value.
+	 * @return the matching enumerator or <code>null</code>.
 	 * @generated
 	 */
 	public static TransportMode get(int value) {
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelImpl.java
index 8c6ab94..b978877 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelImpl.java
@@ -25,10 +25,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.AreaLabelImpl#getCurrentAreaValue <em>Current Area Value</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelValueImpl.java
index 3668f24..124c5f7 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/AreaLabelValueImpl.java
@@ -23,11 +23,11 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.AreaLabelValueImpl#getArea <em>Area</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.AreaLabelValueImpl#getAverageExtent <em>Average Extent</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelImpl.java
index 54532d7..c26144c 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelImpl.java
@@ -27,8 +27,6 @@
 /**
  * <!-- begin-user-doc --> An implementation of the model object '<em><b>Common Border Relationship Label</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelValueImpl.java
index 35b9f69..de7bb16 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/CommonBorderRelationshipLabelValueImpl.java
@@ -22,10 +22,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.CommonBorderRelationshipLabelValueImpl#getBorderLength <em>Border Length</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/DoubleLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/DoubleLabelValueImpl.java
new file mode 100644
index 0000000..989d8bc
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/DoubleLabelValueImpl.java
@@ -0,0 +1,48 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.stem.definitions.labels.DoubleLabelValue;
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Double Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class DoubleLabelValueImpl extends GenericLabelValueImpl<Double> implements DoubleLabelValue {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected DoubleLabelValueImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return LabelsPackage.Literals.DOUBLE_LABEL_VALUE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * This is specialized for the more specific type known in this context.
+	 * @generated
+	 */
+	@Override
+	public void setValue(Double newValue) {
+		super.setValue(newValue);
+	}
+
+} //DoubleLabelValueImpl
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelImpl.java
index 789ad8a..3138117 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelImpl.java
@@ -25,10 +25,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.EarthScienceLabelImpl#getCurrentEarthScienceValue <em>Current Earth Science Value</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelValueImpl.java
index 838dd5e..e85d886 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/EarthScienceLabelValueImpl.java
@@ -27,6 +27,7 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.EarthScienceLabelValueImpl#getDataType <em>Data Type</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.EarthScienceLabelValueImpl#getUnits <em>Units</em>}</li>
@@ -42,7 +43,6 @@
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.EarthScienceLabelValueImpl#getRange <em>Range</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.EarthScienceLabelValueImpl#getValidYear <em>Valid Year</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/GenericLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/GenericLabelValueImpl.java
new file mode 100644
index 0000000..f7ba993
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/GenericLabelValueImpl.java
@@ -0,0 +1,274 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.stem.core.graph.impl.LabelValueImpl;
+
+import org.eclipse.stem.definitions.labels.GenericLabelValue;
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Generic Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl#getValue <em>Value</em>}</li>
+ *   <li>{@link org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl#getUnit <em>Unit</em>}</li>
+ *   <li>{@link org.eclipse.stem.definitions.labels.impl.GenericLabelValueImpl#getMeasure <em>Measure</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class GenericLabelValueImpl<T> extends LabelValueImpl implements GenericLabelValue<T> {
+	/**
+	 * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected T value;
+
+	/**
+	 * The default value of the '{@link #getUnit() <em>Unit</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUnit()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String UNIT_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getUnit() <em>Unit</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getUnit()
+	 * @generated
+	 * @ordered
+	 */
+	protected String unit = UNIT_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getMeasure() <em>Measure</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMeasure()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String MEASURE_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getMeasure() <em>Measure</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getMeasure()
+	 * @generated
+	 * @ordered
+	 */
+	protected String measure = MEASURE_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected GenericLabelValueImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return LabelsPackage.Literals.GENERIC_LABEL_VALUE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public T getValue() {
+		return value;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setValue(T newValue) {
+		T oldValue = value;
+		value = newValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, LabelsPackage.GENERIC_LABEL_VALUE__VALUE, oldValue, value));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getUnit() {
+		return unit;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setUnit(String newUnit) {
+		String oldUnit = unit;
+		unit = newUnit;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, LabelsPackage.GENERIC_LABEL_VALUE__UNIT, oldUnit, unit));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getMeasure() {
+		return measure;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setMeasure(String newMeasure) {
+		String oldMeasure = measure;
+		measure = newMeasure;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, LabelsPackage.GENERIC_LABEL_VALUE__MEASURE, oldMeasure, measure));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Class<?> getJavaTypeClass() {
+		// TODO: implement this method
+		// Ensure that you remove @generated or mark it @generated NOT
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case LabelsPackage.GENERIC_LABEL_VALUE__VALUE:
+				return getValue();
+			case LabelsPackage.GENERIC_LABEL_VALUE__UNIT:
+				return getUnit();
+			case LabelsPackage.GENERIC_LABEL_VALUE__MEASURE:
+				return getMeasure();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case LabelsPackage.GENERIC_LABEL_VALUE__VALUE:
+				setValue((T)newValue);
+				return;
+			case LabelsPackage.GENERIC_LABEL_VALUE__UNIT:
+				setUnit((String)newValue);
+				return;
+			case LabelsPackage.GENERIC_LABEL_VALUE__MEASURE:
+				setMeasure((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case LabelsPackage.GENERIC_LABEL_VALUE__VALUE:
+				setValue((T)null);
+				return;
+			case LabelsPackage.GENERIC_LABEL_VALUE__UNIT:
+				setUnit(UNIT_EDEFAULT);
+				return;
+			case LabelsPackage.GENERIC_LABEL_VALUE__MEASURE:
+				setMeasure(MEASURE_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case LabelsPackage.GENERIC_LABEL_VALUE__VALUE:
+				return value != null;
+			case LabelsPackage.GENERIC_LABEL_VALUE__UNIT:
+				return UNIT_EDEFAULT == null ? unit != null : !UNIT_EDEFAULT.equals(unit);
+			case LabelsPackage.GENERIC_LABEL_VALUE__MEASURE:
+				return MEASURE_EDEFAULT == null ? measure != null : !MEASURE_EDEFAULT.equals(measure);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (value: "); //$NON-NLS-1$
+		result.append(value);
+		result.append(", unit: "); //$NON-NLS-1$
+		result.append(unit);
+		result.append(", measure: "); //$NON-NLS-1$
+		result.append(measure);
+		result.append(')');
+		return result.toString();
+	}
+
+} //GenericLabelValueImpl
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/IntegerLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/IntegerLabelValueImpl.java
new file mode 100644
index 0000000..f521bf7
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/IntegerLabelValueImpl.java
@@ -0,0 +1,48 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.stem.definitions.labels.IntegerLabelValue;
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Integer Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class IntegerLabelValueImpl extends GenericLabelValueImpl<Integer> implements IntegerLabelValue {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IntegerLabelValueImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return LabelsPackage.Literals.INTEGER_LABEL_VALUE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * This is specialized for the more specific type known in this context.
+	 * @generated
+	 */
+	@Override
+	public void setValue(Integer newValue) {
+		super.setValue(newValue);
+	}
+
+} //IntegerLabelValueImpl
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/KeyValueLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/KeyValueLabelValueImpl.java
new file mode 100644
index 0000000..3b6e9a9
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/KeyValueLabelValueImpl.java
@@ -0,0 +1,50 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.impl;
+
+import java.util.Map;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.stem.definitions.labels.KeyValueLabelValue;
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Key Value Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class KeyValueLabelValueImpl extends GenericLabelValueImpl<Map<String, Object>> implements KeyValueLabelValue {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated NOT
+	 */
+	protected KeyValueLabelValueImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return LabelsPackage.Literals.KEY_VALUE_LABEL_VALUE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * This is specialized for the more specific type known in this context.
+	 * @generated
+	 */
+	@Override
+	public void setValue(Map<String, Object> newValue) {
+		super.setValue(newValue);
+	}
+
+} //KeyValueLabelValueImpl
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsFactoryImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsFactoryImpl.java
index 3050c64..b6e94ff 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsFactoryImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsFactoryImpl.java
@@ -17,6 +17,7 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.stem.definitions.labels.*;
 import org.eclipse.stem.definitions.labels.AreaLabel;
 import org.eclipse.stem.definitions.labels.AreaLabelValue;
 import org.eclipse.stem.definitions.labels.CommonBorderRelationshipLabel;
@@ -52,7 +53,7 @@
 	 */
 	public static LabelsFactory init() {
 		try {
-			LabelsFactory theLabelsFactory = (LabelsFactory)EPackage.Registry.INSTANCE.getEFactory("http:///org/eclipse/stem/definitions/labels.ecore"); //$NON-NLS-1$ 
+			LabelsFactory theLabelsFactory = (LabelsFactory)EPackage.Registry.INSTANCE.getEFactory(LabelsPackage.eNS_URI);
 			if (theLabelsFactory != null) {
 				return theLabelsFactory;
 			}
@@ -96,6 +97,12 @@
 			case LabelsPackage.ROAD_TRANSPORT_RELATIONSHIP_LABEL_VALUE: return createRoadTransportRelationshipLabelValue();
 			case LabelsPackage.EARTH_SCIENCE_LABEL: return createEarthScienceLabel();
 			case LabelsPackage.EARTH_SCIENCE_LABEL_VALUE: return createEarthScienceLabelValue();
+			case LabelsPackage.GENERIC_LABEL_VALUE: return createGenericLabelValue();
+			case LabelsPackage.DOUBLE_LABEL_VALUE: return createDoubleLabelValue();
+			case LabelsPackage.INTEGER_LABEL_VALUE: return createIntegerLabelValue();
+			case LabelsPackage.LONG_LABEL_VALUE: return createLongLabelValue();
+			case LabelsPackage.STRING_LABEL_VALUE: return createStringLabelValue();
+			case LabelsPackage.KEY_VALUE_LABEL_VALUE: return createKeyValueLabelValue();
 			default:
 				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$
 		}
@@ -305,6 +312,72 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	@Override
+	public <T> GenericLabelValue<T> createGenericLabelValue() {
+		GenericLabelValueImpl<T> genericLabelValue = new GenericLabelValueImpl<T>();
+		return genericLabelValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public DoubleLabelValue createDoubleLabelValue() {
+		DoubleLabelValueImpl doubleLabelValue = new DoubleLabelValueImpl();
+		return doubleLabelValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public IntegerLabelValue createIntegerLabelValue() {
+		IntegerLabelValueImpl integerLabelValue = new IntegerLabelValueImpl();
+		return integerLabelValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public LongLabelValue createLongLabelValue() {
+		LongLabelValueImpl longLabelValue = new LongLabelValueImpl();
+		return longLabelValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public StringLabelValue createStringLabelValue() {
+		StringLabelValueImpl stringLabelValue = new StringLabelValueImpl();
+		return stringLabelValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public KeyValueLabelValue createKeyValueLabelValue() {
+		KeyValueLabelValueImpl keyValueLabelValue = new KeyValueLabelValueImpl();
+		return keyValueLabelValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public RelativePhysicalRelationship createRelativePhysicalRelationshipFromString(EDataType eDataType, String initialValue) {
 		RelativePhysicalRelationship result = RelativePhysicalRelationship.get(initialValue);
 		if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsPackageImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsPackageImpl.java
index cbfe052..5238759 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsPackageImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LabelsPackageImpl.java
@@ -14,8 +14,11 @@
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EEnum;
+import org.eclipse.emf.ecore.EGenericType;
+import org.eclipse.emf.ecore.EOperation;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.ETypeParameter;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.emf.ecore.impl.EPackageImpl;
 import org.eclipse.stem.core.common.CommonPackage;
@@ -32,10 +35,15 @@
 import org.eclipse.stem.definitions.labels.AreaLabelValue;
 import org.eclipse.stem.definitions.labels.CommonBorderRelationshipLabel;
 import org.eclipse.stem.definitions.labels.CommonBorderRelationshipLabelValue;
+import org.eclipse.stem.definitions.labels.DoubleLabelValue;
 import org.eclipse.stem.definitions.labels.EarthScienceLabel;
 import org.eclipse.stem.definitions.labels.EarthScienceLabelValue;
+import org.eclipse.stem.definitions.labels.GenericLabelValue;
+import org.eclipse.stem.definitions.labels.IntegerLabelValue;
+import org.eclipse.stem.definitions.labels.KeyValueLabelValue;
 import org.eclipse.stem.definitions.labels.LabelsFactory;
 import org.eclipse.stem.definitions.labels.LabelsPackage;
+import org.eclipse.stem.definitions.labels.LongLabelValue;
 import org.eclipse.stem.definitions.labels.PhysicalRelationshipLabel;
 import org.eclipse.stem.definitions.labels.PhysicalRelationshipLabelValue;
 import org.eclipse.stem.definitions.labels.PopulationLabel;
@@ -45,6 +53,7 @@
 import org.eclipse.stem.definitions.labels.RelativePhysicalRelationshipLabelValue;
 import org.eclipse.stem.definitions.labels.RoadTransportRelationshipLabel;
 import org.eclipse.stem.definitions.labels.RoadTransportRelationshipLabelValue;
+import org.eclipse.stem.definitions.labels.StringLabelValue;
 import org.eclipse.stem.definitions.labels.TransportMode;
 import org.eclipse.stem.definitions.labels.TransportRelationshipLabel;
 import org.eclipse.stem.definitions.labels.TransportRelationshipLabelValue;
@@ -177,6 +186,48 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	private EClass genericLabelValueEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass doubleLabelValueEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass integerLabelValueEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass longLabelValueEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass stringLabelValueEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass keyValueLabelValueEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	private EEnum relativePhysicalRelationshipEEnum = null;
 
 	/**
@@ -844,6 +895,96 @@
 	 * @generated
 	 */
 	@Override
+	public EClass getGenericLabelValue() {
+		return genericLabelValueEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getGenericLabelValue_Value() {
+		return (EAttribute)genericLabelValueEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getGenericLabelValue_Unit() {
+		return (EAttribute)genericLabelValueEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getGenericLabelValue_Measure() {
+		return (EAttribute)genericLabelValueEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getDoubleLabelValue() {
+		return doubleLabelValueEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getIntegerLabelValue() {
+		return integerLabelValueEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getLongLabelValue() {
+		return longLabelValueEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getStringLabelValue() {
+		return stringLabelValueEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EClass getKeyValueLabelValue() {
+		return keyValueLabelValueEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
 	public EEnum getRelativePhysicalRelationship() {
 		return relativePhysicalRelationshipEEnum;
 	}
@@ -960,6 +1101,21 @@
 		createEAttribute(earthScienceLabelValueEClass, EARTH_SCIENCE_LABEL_VALUE__RANGE);
 		createEAttribute(earthScienceLabelValueEClass, EARTH_SCIENCE_LABEL_VALUE__VALID_YEAR);
 
+		genericLabelValueEClass = createEClass(GENERIC_LABEL_VALUE);
+		createEAttribute(genericLabelValueEClass, GENERIC_LABEL_VALUE__VALUE);
+		createEAttribute(genericLabelValueEClass, GENERIC_LABEL_VALUE__UNIT);
+		createEAttribute(genericLabelValueEClass, GENERIC_LABEL_VALUE__MEASURE);
+
+		doubleLabelValueEClass = createEClass(DOUBLE_LABEL_VALUE);
+
+		integerLabelValueEClass = createEClass(INTEGER_LABEL_VALUE);
+
+		longLabelValueEClass = createEClass(LONG_LABEL_VALUE);
+
+		stringLabelValueEClass = createEClass(STRING_LABEL_VALUE);
+
+		keyValueLabelValueEClass = createEClass(KEY_VALUE_LABEL_VALUE);
+
 		// Create enums
 		relativePhysicalRelationshipEEnum = createEEnum(RELATIVE_PHYSICAL_RELATIONSHIP);
 		transportModeEEnum = createEEnum(TRANSPORT_MODE);
@@ -993,6 +1149,7 @@
 		EcorePackage theEcorePackage = (EcorePackage)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
 
 		// Create type parameters
+		ETypeParameter genericLabelValueEClass_T = addETypeParameter(genericLabelValueEClass, "T"); //$NON-NLS-1$
 
 		// Set bounds for type parameters
 
@@ -1013,6 +1170,31 @@
 		roadTransportRelationshipLabelValueEClass.getESuperTypes().add(this.getPhysicalRelationshipLabelValue());
 		earthScienceLabelEClass.getESuperTypes().add(theGraphPackage.getStaticNodeLabel());
 		earthScienceLabelValueEClass.getESuperTypes().add(theGraphPackage.getLabelValue());
+		genericLabelValueEClass.getESuperTypes().add(theGraphPackage.getLabelValue());
+		EGenericType g1 = createEGenericType(this.getGenericLabelValue());
+		EGenericType g2 = createEGenericType(ecorePackage.getEDoubleObject());
+		g1.getETypeArguments().add(g2);
+		doubleLabelValueEClass.getEGenericSuperTypes().add(g1);
+		g1 = createEGenericType(this.getGenericLabelValue());
+		g2 = createEGenericType(ecorePackage.getEIntegerObject());
+		g1.getETypeArguments().add(g2);
+		integerLabelValueEClass.getEGenericSuperTypes().add(g1);
+		g1 = createEGenericType(this.getGenericLabelValue());
+		g2 = createEGenericType(ecorePackage.getELongObject());
+		g1.getETypeArguments().add(g2);
+		longLabelValueEClass.getEGenericSuperTypes().add(g1);
+		g1 = createEGenericType(this.getGenericLabelValue());
+		g2 = createEGenericType(ecorePackage.getEString());
+		g1.getETypeArguments().add(g2);
+		stringLabelValueEClass.getEGenericSuperTypes().add(g1);
+		g1 = createEGenericType(this.getGenericLabelValue());
+		g2 = createEGenericType(ecorePackage.getEMap());
+		g1.getETypeArguments().add(g2);
+		EGenericType g3 = createEGenericType(ecorePackage.getEString());
+		g2.getETypeArguments().add(g3);
+		g3 = createEGenericType(ecorePackage.getEJavaObject());
+		g2.getETypeArguments().add(g3);
+		keyValueLabelValueEClass.getEGenericSuperTypes().add(g1);
 
 		// Initialize classes and features; add operations and parameters
 		initEClass(areaLabelEClass, AreaLabel.class, "AreaLabel", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
@@ -1088,6 +1270,28 @@
 		initEAttribute(getEarthScienceLabelValue_Range(), theEcorePackage.getEDouble(), "range", null, 0, -1, EarthScienceLabelValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
 		initEAttribute(getEarthScienceLabelValue_ValidYear(), theEcorePackage.getEInt(), "validYear", "0", 0, 1, EarthScienceLabelValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ //$NON-NLS-2$
 
+		initEClass(genericLabelValueEClass, GenericLabelValue.class, "GenericLabelValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+		g1 = createEGenericType(genericLabelValueEClass_T);
+		initEAttribute(getGenericLabelValue_Value(), g1, "value", null, 0, 1, GenericLabelValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getGenericLabelValue_Unit(), ecorePackage.getEString(), "unit", null, 0, 1, GenericLabelValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+		initEAttribute(getGenericLabelValue_Measure(), ecorePackage.getEString(), "measure", null, 0, 1, GenericLabelValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
+
+		EOperation op = addEOperation(genericLabelValueEClass, null, "getJavaTypeClass", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$
+		g1 = createEGenericType(ecorePackage.getEJavaClass());
+		g2 = createEGenericType();
+		g1.getETypeArguments().add(g2);
+		initEOperation(op, g1);
+
+		initEClass(doubleLabelValueEClass, DoubleLabelValue.class, "DoubleLabelValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+
+		initEClass(integerLabelValueEClass, IntegerLabelValue.class, "IntegerLabelValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+
+		initEClass(longLabelValueEClass, LongLabelValue.class, "LongLabelValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+
+		initEClass(stringLabelValueEClass, StringLabelValue.class, "StringLabelValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+
+		initEClass(keyValueLabelValueEClass, KeyValueLabelValue.class, "KeyValueLabelValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
+
 		// Initialize enums and add enum literals
 		initEEnum(relativePhysicalRelationshipEEnum, RelativePhysicalRelationship.class, "RelativePhysicalRelationship"); //$NON-NLS-1$
 		addEEnumLiteral(relativePhysicalRelationshipEEnum, RelativePhysicalRelationship.UNSPECIFIED_LITERAL);
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LongLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LongLabelValueImpl.java
new file mode 100644
index 0000000..a80c2c8
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/LongLabelValueImpl.java
@@ -0,0 +1,48 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+import org.eclipse.stem.definitions.labels.LongLabelValue;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Long Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class LongLabelValueImpl extends GenericLabelValueImpl<Long> implements LongLabelValue {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected LongLabelValueImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return LabelsPackage.Literals.LONG_LABEL_VALUE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * This is specialized for the more specific type known in this context.
+	 * @generated
+	 */
+	@Override
+	public void setValue(Long newValue) {
+		super.setValue(newValue);
+	}
+
+} //LongLabelValueImpl
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelImpl.java
index dbc7a34..8ec1282 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelImpl.java
@@ -23,8 +23,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model object '<em><b>Physical Relationship Label</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelValueImpl.java
index 267269b..5957e01 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PhysicalRelationshipLabelValueImpl.java
@@ -20,8 +20,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model object '<em><b>Physical Relationship Label Value</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelImpl.java
index 506a88b..524eef0 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelImpl.java
@@ -31,13 +31,13 @@
  * <em><b>Population Label</b></em>'. <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.PopulationLabelImpl#getPopulationIdentifier <em>Population Identifier</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.PopulationLabelImpl#getCurrentPopulationValue <em>Current Population Value</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.PopulationLabelImpl#getPopulatedArea <em>Populated Area</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.PopulationLabelImpl#getValidYear <em>Valid Year</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelValueImpl.java
index 0364f06..d52649a 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/PopulationLabelValueImpl.java
@@ -23,10 +23,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.PopulationLabelValueImpl#getCount <em>Count</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelImpl.java
index ea2d931..59ba6e5 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelImpl.java
@@ -22,10 +22,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.RelativePhysicalRelationshipLabelImpl#getCurrentRelationship <em>Current Relationship</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelValueImpl.java
index 708d603..e5346b9 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RelativePhysicalRelationshipLabelValueImpl.java
@@ -24,11 +24,11 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.RelativePhysicalRelationshipLabelValueImpl#isAdjacent <em>Adjacent</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.RelativePhysicalRelationshipLabelValueImpl#getRelationship <em>Relationship</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelImpl.java
index d764d18..f9eb929 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelImpl.java
@@ -29,8 +29,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model object '<em><b>Road Transport Relationship Label</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelValueImpl.java
index 5d007ed..1ff7624 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/RoadTransportRelationshipLabelValueImpl.java
@@ -24,12 +24,12 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.RoadTransportRelationshipLabelValueImpl#getRoadName <em>Road Name</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.RoadTransportRelationshipLabelValueImpl#getRoadClass <em>Road Class</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.RoadTransportRelationshipLabelValueImpl#getNumberCrossings <em>Number Crossings</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/StringLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/StringLabelValueImpl.java
new file mode 100644
index 0000000..0623213
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/StringLabelValueImpl.java
@@ -0,0 +1,48 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.impl;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+import org.eclipse.stem.definitions.labels.StringLabelValue;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>String Label Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StringLabelValueImpl extends GenericLabelValueImpl<String> implements StringLabelValue {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected StringLabelValueImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return LabelsPackage.Literals.STRING_LABEL_VALUE;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * This is specialized for the more specific type known in this context.
+	 * @generated
+	 */
+	@Override
+	public void setValue(String newValue) {
+		super.setValue(newValue);
+	}
+
+} //StringLabelValueImpl
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelImpl.java
index ab84405..f52185d 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelImpl.java
@@ -39,6 +39,7 @@
  * <em><b>Transport Relationship Label</b></em>'. <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.TransportRelationshipLabelImpl#getTransportMode <em>Transport Mode</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.TransportRelationshipLabelImpl#getPopulationIdentifier <em>Population Identifier</em>}</li>
@@ -52,7 +53,6 @@
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.TransportRelationshipLabelImpl#getTransitTime <em>Transit Time</em>}</li>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.TransportRelationshipLabelImpl#getStartUpDelay <em>Start Up Delay</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelValueImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelValueImpl.java
index ac2f31d..07453d1 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelValueImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/impl/TransportRelationshipLabelValueImpl.java
@@ -23,10 +23,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.labels.impl.TransportRelationshipLabelValueImpl#getAvailableDepartureCapacityProportion <em>Available Departure Capacity Proportion</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsActionBarContributor.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsActionBarContributor.java
index 1c92167..875e11b 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsActionBarContributor.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsActionBarContributor.java
@@ -206,8 +206,7 @@
 		//
 		submenuManager.addMenuListener
 			(new IMenuListener() {
-				 @Override
-				public void menuAboutToShow(IMenuManager menuManager) {
+				 public void menuAboutToShow(IMenuManager menuManager) {
 					 menuManager.updateAll(true);
 				 }
 			 });
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsEditor.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsEditor.java
index 692c4f8..b97d98d 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsEditor.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/presentation/LabelsEditor.java
@@ -81,6 +81,7 @@
 import org.eclipse.jface.action.Separator;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.util.LocalSelectionTransfer;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.ISelectionChangedListener;
 import org.eclipse.jface.viewers.ISelectionProvider;
@@ -106,6 +107,7 @@
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.FileTransfer;
 import org.eclipse.swt.dnd.Transfer;
 import org.eclipse.swt.events.ControlAdapter;
 import org.eclipse.swt.events.ControlEvent;
@@ -188,7 +190,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	protected PropertySheetPage propertySheetPage;
+	protected List<PropertySheetPage> propertySheetPages = new ArrayList<PropertySheetPage>();
 
 	/**
 	 * This is the viewer that shadows the selection in the content outline.
@@ -248,7 +250,6 @@
 	 */
 	protected IPartListener partListener =
 		new IPartListener() {
-			@Override
 			public void partActivated(IWorkbenchPart p) {
 				if (p instanceof ContentOutline) {
 					if (((ContentOutline)p).getCurrentPage() == contentOutlinePage) {
@@ -258,7 +259,7 @@
 					}
 				}
 				else if (p instanceof PropertySheet) {
-					if (((PropertySheet)p).getCurrentPage() == propertySheetPage) {
+					if (propertySheetPages.contains(((PropertySheet)p).getCurrentPage())) {
 						getActionBarContributor().setActiveEditor(LabelsEditor.this);
 						handleActivate();
 					}
@@ -267,19 +268,15 @@
 					handleActivate();
 				}
 			}
-			@Override
 			public void partBroughtToTop(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partClosed(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partDeactivated(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partOpened(IWorkbenchPart p) {
 				// Ignore.
 			}
@@ -352,8 +349,7 @@
 							if (updateProblemIndication) {
 								getSite().getShell().getDisplay().asyncExec
 									(new Runnable() {
-										 @Override
-										public void run() {
+										 public void run() {
 											 updateProblemIndication();
 										 }
 									 });
@@ -375,6 +371,15 @@
 			@Override
 			protected void unsetTarget(Resource target) {
 				basicUnsetTarget(target);
+				resourceToDiagnosticMap.remove(target);
+				if (updateProblemIndication) {
+					getSite().getShell().getDisplay().asyncExec
+						(new Runnable() {
+							 public void run() {
+								 updateProblemIndication();
+							 }
+						 });
+				}
 			}
 		};
 
@@ -386,7 +391,6 @@
 	 */
 	protected IResourceChangeListener resourceChangeListener =
 		new IResourceChangeListener() {
-			@Override
 			public void resourceChanged(IResourceChangeEvent event) {
 				IResourceDelta delta = event.getDelta();
 				try {
@@ -395,7 +399,6 @@
 						protected Collection<Resource> changedResources = new ArrayList<Resource>();
 						protected Collection<Resource> removedResources = new ArrayList<Resource>();
 
-						@Override
 						public boolean visit(IResourceDelta delta) {
 							if (delta.getResource().getType() == IResource.FILE) {
 								if (delta.getKind() == IResourceDelta.REMOVED ||
@@ -410,6 +413,7 @@
 										}
 									}
 								}
+								return false;
 							}
 
 							return true;
@@ -430,8 +434,7 @@
 					if (!visitor.getRemovedResources().isEmpty()) {
 						getSite().getShell().getDisplay().asyncExec
 							(new Runnable() {
-								 @Override
-								public void run() {
+								 public void run() {
 									 removedResources.addAll(visitor.getRemovedResources());
 									 if (!isDirty()) {
 										 getSite().getPage().closeEditor(LabelsEditor.this, false);
@@ -443,8 +446,7 @@
 					if (!visitor.getChangedResources().isEmpty()) {
 						getSite().getShell().getDisplay().asyncExec
 							(new Runnable() {
-								 @Override
-								public void run() {
+								 public void run() {
 									 changedResources.addAll(visitor.getChangedResources());
 									 if (getSite().getPage().getActiveEditor() == LabelsEditor.this) {
 										 handleActivate();
@@ -648,12 +650,10 @@
 		//
 		commandStack.addCommandStackListener
 			(new CommandStackListener() {
-				 @Override
-				public void commandStackChanged(final EventObject event) {
+				 public void commandStackChanged(final EventObject event) {
 					 getContainer().getDisplay().asyncExec
 						 (new Runnable() {
-							  @Override
-							public void run() {
+							  public void run() {
 								  firePropertyChange(IEditorPart.PROP_DIRTY);
 
 								  // Try to select the affected objects.
@@ -662,8 +662,14 @@
 								  if (mostRecentCommand != null) {
 									  setSelectionToViewer(mostRecentCommand.getAffectedObjects());
 								  }
-								  if (propertySheetPage != null && !propertySheetPage.getControl().isDisposed()) {
-									  propertySheetPage.refresh();
+								  for (Iterator<PropertySheetPage> i = propertySheetPages.iterator(); i.hasNext(); ) {
+									  PropertySheetPage propertySheetPage = i.next();
+									  if (propertySheetPage.getControl().isDisposed()) {
+										  i.remove();
+									  }
+									  else {
+										  propertySheetPage.refresh();
+									  }
 								  }
 							  }
 						  });
@@ -699,7 +705,6 @@
 		if (theSelection != null && !theSelection.isEmpty()) {
 			Runnable runnable =
 				new Runnable() {
-					@Override
 					public void run() {
 						// Try to select the items in the current content viewer of the editor.
 						//
@@ -777,7 +782,6 @@
 					new ISelectionChangedListener() {
 						// This just notifies those things that are affected by the section.
 						//
-						@Override
 						public void selectionChanged(SelectionChangedEvent selectionChangedEvent) {
 							setSelection(selectionChangedEvent.getSelection());
 						}
@@ -833,7 +837,7 @@
 		getSite().registerContextMenu(contextMenu, new UnwrappingSelectionProvider(viewer));
 
 		int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
-		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() };
+		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance(), LocalSelectionTransfer.getTransfer(), FileTransfer.getInstance() };
 		viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(viewer));
 		viewer.addDropSupport(dndOperations, transfers, new EditingDomainViewerDropAdapter(editingDomain, viewer));
 	}
@@ -873,10 +877,11 @@
 	 * @generated
 	 */
 	public Diagnostic analyzeResourceProblems(Resource resource, Exception exception) {
-		if (!resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty()) {
+		boolean hasErrors = !resource.getErrors().isEmpty();
+		if (hasErrors || !resource.getWarnings().isEmpty()) {
 			BasicDiagnostic basicDiagnostic =
 				new BasicDiagnostic
-					(Diagnostic.ERROR,
+					(hasErrors ? Diagnostic.ERROR : Diagnostic.WARNING,
 					 "org.eclipse.stem.definitions", //$NON-NLS-1$
 					 0,
 					 getString("_UI_CreateModelError_message", resource.getURI()), //$NON-NLS-1$
@@ -932,8 +937,7 @@
 
 			getSite().getShell().getDisplay().asyncExec
 				(new Runnable() {
-					 @Override
-					public void run() {
+					 public void run() {
 						 setActivePage(0);
 					 }
 				 });
@@ -957,8 +961,7 @@
 
 		getSite().getShell().getDisplay().asyncExec
 			(new Runnable() {
-				 @Override
-				public void run() {
+				 public void run() {
 					 updateProblemIndication();
 				 }
 			 });
@@ -1093,8 +1096,7 @@
 				(new ISelectionChangedListener() {
 					 // This ensures that we handle selections correctly.
 					 //
-					 @Override
-					public void selectionChanged(SelectionChangedEvent event) {
+					 public void selectionChanged(SelectionChangedEvent event) {
 						 handleContentOutlineSelection(event.getSelection());
 					 }
 				 });
@@ -1110,23 +1112,22 @@
 	 * @generated
 	 */
 	public IPropertySheetPage getPropertySheetPage() {
-		if (propertySheetPage == null) {
-			propertySheetPage =
-				new ExtendedPropertySheetPage(editingDomain) {
-					@Override
-					public void setSelectionToViewer(List<?> selection) {
-						LabelsEditor.this.setSelectionToViewer(selection);
-						LabelsEditor.this.setFocus();
-					}
+		PropertySheetPage propertySheetPage =
+			new ExtendedPropertySheetPage(editingDomain) {
+				@Override
+				public void setSelectionToViewer(List<?> selection) {
+					LabelsEditor.this.setSelectionToViewer(selection);
+					LabelsEditor.this.setFocus();
+				}
 
-					@Override
-					public void setActionBars(IActionBars actionBars) {
-						super.setActionBars(actionBars);
-						getActionBarContributor().shareGlobalActions(this, actionBars);
-					}
-				};
-			propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
-		}
+				@Override
+				public void setActionBars(IActionBars actionBars) {
+					super.setActionBars(actionBars);
+					getActionBarContributor().shareGlobalActions(this, actionBars);
+				}
+			};
+		propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
+		propertySheetPages.add(propertySheetPage);
 
 		return propertySheetPage;
 	}
@@ -1181,6 +1182,7 @@
 		//
 		final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
 		saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
+		saveOptions.put(Resource.OPTION_LINE_DELIMITER, Resource.OPTION_LINE_DELIMITER_UNSPECIFIED);
 
 		// Do the work within an operation because this is a long running activity that modifies the workbench.
 		//
@@ -1233,7 +1235,7 @@
 
 	/**
 	 * This returns whether something has been persisted to the URI of the specified resource.
-	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream. 
+	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -1306,20 +1308,9 @@
 	 */
 	@Override
 	public void gotoMarker(IMarker marker) {
-		try {
-			if (marker.getType().equals(EValidator.MARKER)) {
-				String uriAttribute = marker.getAttribute(EValidator.URI_ATTRIBUTE, null);
-				if (uriAttribute != null) {
-					URI uri = URI.createURI(uriAttribute);
-					EObject eObject = editingDomain.getResourceSet().getEObject(uri, true);
-					if (eObject != null) {
-					  setSelectionToViewer(Collections.singleton(editingDomain.getWrapper(eObject)));
-					}
-				}
-			}
-		}
-		catch (CoreException exception) {
-			DefinitionsEditPlugin.INSTANCE.log(exception);
+		List<?> targetObjects = markerHelper.getTargetObjects(editingDomain, marker);
+		if (!targetObjects.isEmpty()) {
+			setSelectionToViewer(targetObjects);
 		}
 	}
 
@@ -1510,7 +1501,7 @@
 			getActionBarContributor().setActiveEditor(null);
 		}
 
-		if (propertySheetPage != null) {
+		for (PropertySheetPage propertySheetPage : propertySheetPages) {
 			propertySheetPage.dispose();
 		}
 
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelItemProvider.java
index 896ceaa..ced890e 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelItemProvider.java
@@ -39,9 +39,7 @@
  * 
  * @generated
  */
-public class AreaLabelItemProvider extends StaticNodeLabelItemProvider
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+public class AreaLabelItemProvider extends StaticNodeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelValueItemProvider.java
index 26a1e44..7ebf011 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/AreaLabelValueItemProvider.java
@@ -39,9 +39,7 @@
  * 
  * @generated
  */
-public class AreaLabelValueItemProvider extends LabelValueItemProvider
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+public class AreaLabelValueItemProvider extends LabelValueItemProvider {
 
 	private static final int NUMBER_OF_FACTIONAL_DIGITS = 2;
 	private static NumberFormat formatter;
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelItemProvider.java
index 3c210d0..87b5ad8 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelItemProvider.java
@@ -34,9 +34,7 @@
  * @generated
  */
 public class CommonBorderRelationshipLabelItemProvider extends
-		PhysicalRelationshipLabelItemProvider implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+		PhysicalRelationshipLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc --> <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelValueItemProvider.java
index a3d285c..36f7870 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/CommonBorderRelationshipLabelValueItemProvider.java
@@ -34,9 +34,7 @@
  * @generated
  */
 public class CommonBorderRelationshipLabelValueItemProvider extends
-		PhysicalRelationshipLabelValueItemProvider implements
-		IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+		PhysicalRelationshipLabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc --> <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/DoubleLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/DoubleLabelValueItemProvider.java
new file mode 100644
index 0000000..6383db5
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/DoubleLabelValueItemProvider.java
@@ -0,0 +1,100 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.stem.definitions.labels.DoubleLabelValue;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.stem.definitions.labels.DoubleLabelValue} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class DoubleLabelValueItemProvider extends GenericLabelValueItemProvider {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public DoubleLabelValueItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns DoubleLabelValue.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/DoubleLabelValue")); //$NON-NLS-1$
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		Object labelValue = ((DoubleLabelValue)object).getValue();
+		String label = labelValue == null ? null : labelValue.toString();
+		return label == null || label.length() == 0 ?
+			getString("_UI_DoubleLabelValue_type") : //$NON-NLS-1$
+			getString("_UI_DoubleLabelValue_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelItemProvider.java
index f6f7c43..cb9ac00 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelItemProvider.java
@@ -37,13 +37,7 @@
  * @generated
  */
 public class EarthScienceLabelItemProvider
-	extends StaticNodeLabelItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends StaticNodeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelValueItemProvider.java
index 14e4aa4..0379901 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/EarthScienceLabelValueItemProvider.java
@@ -38,13 +38,7 @@
  * @generated
  */
 public class EarthScienceLabelValueItemProvider
-	extends LabelValueItemProvider
-	implements
-		IEditingDomainItemProvider,
-		IStructuredItemContentProvider,
-		ITreeItemContentProvider,
-		IItemLabelProvider,
-		IItemPropertySource {
+	extends LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/GenericLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/GenericLabelValueItemProvider.java
new file mode 100644
index 0000000..7525ec0
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/GenericLabelValueItemProvider.java
@@ -0,0 +1,198 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.ResourceLocator;
+
+import org.eclipse.emf.edit.provider.ComposeableAdapterFactory;
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ItemPropertyDescriptor;
+import org.eclipse.emf.edit.provider.ViewerNotification;
+
+import org.eclipse.stem.core.graph.provider.LabelValueItemProvider;
+
+import org.eclipse.stem.definitions.edges.provider.DefinitionsEditPlugin;
+
+import org.eclipse.stem.definitions.labels.GenericLabelValue;
+import org.eclipse.stem.definitions.labels.LabelsPackage;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.stem.definitions.labels.GenericLabelValue} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class GenericLabelValueItemProvider extends LabelValueItemProvider {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public GenericLabelValueItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+			addValuePropertyDescriptor(object);
+			addUnitPropertyDescriptor(object);
+			addMeasurePropertyDescriptor(object);
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This adds a property descriptor for the Value feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addValuePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_GenericLabelValue_value_feature"), //$NON-NLS-1$
+				 getString("_UI_PropertyDescriptor_description", "_UI_GenericLabelValue_value_feature", "_UI_GenericLabelValue_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				 LabelsPackage.Literals.GENERIC_LABEL_VALUE__VALUE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Unit feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addUnitPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_GenericLabelValue_unit_feature"), //$NON-NLS-1$
+				 getString("_UI_PropertyDescriptor_description", "_UI_GenericLabelValue_unit_feature", "_UI_GenericLabelValue_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				 LabelsPackage.Literals.GENERIC_LABEL_VALUE__UNIT,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This adds a property descriptor for the Measure feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addMeasurePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_GenericLabelValue_measure_feature"), //$NON-NLS-1$
+				 getString("_UI_PropertyDescriptor_description", "_UI_GenericLabelValue_measure_feature", "_UI_GenericLabelValue_type"), //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+				 LabelsPackage.Literals.GENERIC_LABEL_VALUE__MEASURE,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
+	 * This returns GenericLabelValue.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/GenericLabelValue")); //$NON-NLS-1$
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		Object labelValue = ((GenericLabelValue<?>)object).getValue();
+		String label = labelValue == null ? null : labelValue.toString();
+		return label == null || label.length() == 0 ?
+			getString("_UI_GenericLabelValue_type") : //$NON-NLS-1$
+			getString("_UI_GenericLabelValue_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+
+		switch (notification.getFeatureID(GenericLabelValue.class)) {
+			case LabelsPackage.GENERIC_LABEL_VALUE__VALUE:
+			case LabelsPackage.GENERIC_LABEL_VALUE__UNIT:
+			case LabelsPackage.GENERIC_LABEL_VALUE__MEASURE:
+				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
+				return;
+		}
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+	/**
+	 * Return the resource locator for this item provider's resources.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public ResourceLocator getResourceLocator() {
+		return DefinitionsEditPlugin.INSTANCE;
+	}
+
+}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/IntegerLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/IntegerLabelValueItemProvider.java
new file mode 100644
index 0000000..043e0e0
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/IntegerLabelValueItemProvider.java
@@ -0,0 +1,100 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.stem.definitions.labels.IntegerLabelValue;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.stem.definitions.labels.IntegerLabelValue} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class IntegerLabelValueItemProvider extends GenericLabelValueItemProvider {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public IntegerLabelValueItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns IntegerLabelValue.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/IntegerLabelValue")); //$NON-NLS-1$
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		Object labelValue = ((IntegerLabelValue)object).getValue();
+		String label = labelValue == null ? null : labelValue.toString();
+		return label == null || label.length() == 0 ?
+			getString("_UI_IntegerLabelValue_type") : //$NON-NLS-1$
+			getString("_UI_IntegerLabelValue_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/KeyValueLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/KeyValueLabelValueItemProvider.java
new file mode 100644
index 0000000..df955eb
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/KeyValueLabelValueItemProvider.java
@@ -0,0 +1,100 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.stem.definitions.labels.KeyValueLabelValue;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.stem.definitions.labels.KeyValueLabelValue} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class KeyValueLabelValueItemProvider extends GenericLabelValueItemProvider {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public KeyValueLabelValueItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns KeyValueLabelValue.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/KeyValueLabelValue")); //$NON-NLS-1$
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		Object labelValue = ((KeyValueLabelValue)object).getValue();
+		String label = labelValue == null ? null : labelValue.toString();
+		return label == null || label.length() == 0 ?
+			getString("_UI_KeyValueLabelValue_type") : //$NON-NLS-1$
+			getString("_UI_KeyValueLabelValue_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LabelsItemProviderAdapterFactory.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LabelsItemProviderAdapterFactory.java
index 7644148..dfaf98d 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LabelsItemProviderAdapterFactory.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LabelsItemProviderAdapterFactory.java
@@ -426,6 +426,144 @@
 	}
 
 	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.stem.definitions.labels.GenericLabelValue} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected GenericLabelValueItemProvider genericLabelValueItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.stem.definitions.labels.GenericLabelValue}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createGenericLabelValueAdapter() {
+		if (genericLabelValueItemProvider == null) {
+			genericLabelValueItemProvider = new GenericLabelValueItemProvider(this);
+		}
+
+		return genericLabelValueItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.stem.definitions.labels.DoubleLabelValue} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected DoubleLabelValueItemProvider doubleLabelValueItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.stem.definitions.labels.DoubleLabelValue}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createDoubleLabelValueAdapter() {
+		if (doubleLabelValueItemProvider == null) {
+			doubleLabelValueItemProvider = new DoubleLabelValueItemProvider(this);
+		}
+
+		return doubleLabelValueItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.stem.definitions.labels.IntegerLabelValue} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected IntegerLabelValueItemProvider integerLabelValueItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.stem.definitions.labels.IntegerLabelValue}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createIntegerLabelValueAdapter() {
+		if (integerLabelValueItemProvider == null) {
+			integerLabelValueItemProvider = new IntegerLabelValueItemProvider(this);
+		}
+
+		return integerLabelValueItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.stem.definitions.labels.LongLabelValue} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected LongLabelValueItemProvider longLabelValueItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.stem.definitions.labels.LongLabelValue}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createLongLabelValueAdapter() {
+		if (longLabelValueItemProvider == null) {
+			longLabelValueItemProvider = new LongLabelValueItemProvider(this);
+		}
+
+		return longLabelValueItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.stem.definitions.labels.StringLabelValue} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected StringLabelValueItemProvider stringLabelValueItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.stem.definitions.labels.StringLabelValue}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createStringLabelValueAdapter() {
+		if (stringLabelValueItemProvider == null) {
+			stringLabelValueItemProvider = new StringLabelValueItemProvider(this);
+		}
+
+		return stringLabelValueItemProvider;
+	}
+
+	/**
+	 * This keeps track of the one adapter used for all {@link org.eclipse.stem.definitions.labels.KeyValueLabelValue} instances.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected KeyValueLabelValueItemProvider keyValueLabelValueItemProvider;
+
+	/**
+	 * This creates an adapter for a {@link org.eclipse.stem.definitions.labels.KeyValueLabelValue}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Adapter createKeyValueLabelValueAdapter() {
+		if (keyValueLabelValueItemProvider == null) {
+			keyValueLabelValueItemProvider = new KeyValueLabelValueItemProvider(this);
+		}
+
+		return keyValueLabelValueItemProvider;
+	}
+
+	/**
 	 * This returns the root adapter factory that contains this factory. <!--
 	 * begin-user-doc -->
 	 * 
@@ -577,6 +715,12 @@
 		if (roadTransportRelationshipLabelValueItemProvider != null) roadTransportRelationshipLabelValueItemProvider.dispose();
 		if (earthScienceLabelItemProvider != null) earthScienceLabelItemProvider.dispose();
 		if (earthScienceLabelValueItemProvider != null) earthScienceLabelValueItemProvider.dispose();
+		if (genericLabelValueItemProvider != null) genericLabelValueItemProvider.dispose();
+		if (doubleLabelValueItemProvider != null) doubleLabelValueItemProvider.dispose();
+		if (integerLabelValueItemProvider != null) integerLabelValueItemProvider.dispose();
+		if (longLabelValueItemProvider != null) longLabelValueItemProvider.dispose();
+		if (stringLabelValueItemProvider != null) stringLabelValueItemProvider.dispose();
+		if (keyValueLabelValueItemProvider != null) keyValueLabelValueItemProvider.dispose();
 	}
 
 }
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LongLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LongLabelValueItemProvider.java
new file mode 100644
index 0000000..31878a2
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/LongLabelValueItemProvider.java
@@ -0,0 +1,100 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.stem.definitions.labels.LongLabelValue;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.stem.definitions.labels.LongLabelValue} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class LongLabelValueItemProvider extends GenericLabelValueItemProvider {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public LongLabelValueItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns LongLabelValue.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/LongLabelValue")); //$NON-NLS-1$
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		Object labelValue = ((LongLabelValue)object).getValue();
+		String label = labelValue == null ? null : labelValue.toString();
+		return label == null || label.length() == 0 ?
+			getString("_UI_LongLabelValue_type") : //$NON-NLS-1$
+			getString("_UI_LongLabelValue_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelItemProvider.java
index eb96375..4c27c52 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelItemProvider.java
@@ -36,9 +36,7 @@
  * <!-- begin-user-doc --> <!-- end-user-doc -->
  * @generated
  */
-public class PhysicalRelationshipLabelItemProvider extends StaticEdgeLabelItemProvider
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+public class PhysicalRelationshipLabelItemProvider extends StaticEdgeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc --> <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelValueItemProvider.java
index 753f8fa..5d313df 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PhysicalRelationshipLabelValueItemProvider.java
@@ -34,13 +34,7 @@
  * @generated
  */
 public class PhysicalRelationshipLabelValueItemProvider
-	extends LabelValueItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelItemProvider.java
index 677f88d..7115de5 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelItemProvider.java
@@ -40,9 +40,7 @@
  * 
  * @generated
  */
-public class PopulationLabelItemProvider extends StaticNodeLabelItemProvider
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+public class PopulationLabelItemProvider extends StaticNodeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelValueItemProvider.java
index 1756734..d3848b7 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/PopulationLabelValueItemProvider.java
@@ -36,9 +36,7 @@
  * <!-- begin-user-doc --> <!-- end-user-doc -->
  * @generated
  */
-public class PopulationLabelValueItemProvider extends LabelValueItemProvider
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+public class PopulationLabelValueItemProvider extends LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelItemProvider.java
index 411f26a..f66f64b 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelItemProvider.java
@@ -35,13 +35,7 @@
  * @generated
  */
 public class RelativePhysicalRelationshipLabelItemProvider
-	extends PhysicalRelationshipLabelItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends PhysicalRelationshipLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelValueItemProvider.java
index 7da5b4d..0b98192 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RelativePhysicalRelationshipLabelValueItemProvider.java
@@ -40,13 +40,7 @@
  * @generated
  */
 public class RelativePhysicalRelationshipLabelValueItemProvider
-	extends LabelValueItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelItemProvider.java
index 8dc8890..019ac29 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelItemProvider.java
@@ -35,13 +35,7 @@
  * @generated
  */
 public class RoadTransportRelationshipLabelItemProvider
-	extends PhysicalRelationshipLabelItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends PhysicalRelationshipLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelValueItemProvider.java
index 6c215f0..7cdc5a3 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/RoadTransportRelationshipLabelValueItemProvider.java
@@ -35,13 +35,7 @@
  * @generated
  */
 public class RoadTransportRelationshipLabelValueItemProvider
-	extends PhysicalRelationshipLabelValueItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends PhysicalRelationshipLabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/StringLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/StringLabelValueItemProvider.java
new file mode 100644
index 0000000..4a60977
--- /dev/null
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/StringLabelValueItemProvider.java
@@ -0,0 +1,100 @@
+/**
+ */
+package org.eclipse.stem.definitions.labels.provider;
+
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.edit.provider.IItemPropertyDescriptor;
+
+import org.eclipse.stem.definitions.labels.StringLabelValue;
+
+/**
+ * This is the item provider adapter for a {@link org.eclipse.stem.definitions.labels.StringLabelValue} object.
+ * <!-- begin-user-doc -->
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class StringLabelValueItemProvider extends GenericLabelValueItemProvider {
+	/**
+	 * This constructs an instance from a factory and a notifier.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public StringLabelValueItemProvider(AdapterFactory adapterFactory) {
+		super(adapterFactory);
+	}
+
+	/**
+	 * This returns the property descriptors for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public List<IItemPropertyDescriptor> getPropertyDescriptors(Object object) {
+		if (itemPropertyDescriptors == null) {
+			super.getPropertyDescriptors(object);
+
+		}
+		return itemPropertyDescriptors;
+	}
+
+	/**
+	 * This returns StringLabelValue.gif.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object getImage(Object object) {
+		return overlayImage(object, getResourceLocator().getImage("full/obj16/StringLabelValue")); //$NON-NLS-1$
+	}
+
+	/**
+	 * This returns the label text for the adapted class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getText(Object object) {
+		Object labelValue = ((StringLabelValue)object).getValue();
+		String label = labelValue == null ? null : labelValue.toString();
+		return label == null || label.length() == 0 ?
+			getString("_UI_StringLabelValue_type") : //$NON-NLS-1$
+			getString("_UI_StringLabelValue_type") + " " + label; //$NON-NLS-1$ //$NON-NLS-2$
+	}
+	
+
+	/**
+	 * This handles model notifications by calling {@link #updateChildren} to update any cached
+	 * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void notifyChanged(Notification notification) {
+		updateChildren(notification);
+		super.notifyChanged(notification);
+	}
+
+	/**
+	 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
+	 * that can be created under this object.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object) {
+		super.collectNewChildDescriptors(newChildDescriptors, object);
+	}
+
+}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelItemProvider.java
index 96dfed8..a630917 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelItemProvider.java
@@ -40,9 +40,7 @@
  * <!-- begin-user-doc --> <!-- end-user-doc -->
  * @generated
  */
-public class TransportRelationshipLabelItemProvider extends DynamicEdgeLabelItemProvider
-		implements IEditingDomainItemProvider, IStructuredItemContentProvider,
-		ITreeItemContentProvider, IItemLabelProvider, IItemPropertySource {
+public class TransportRelationshipLabelItemProvider extends DynamicEdgeLabelItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc --> <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelValueItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelValueItemProvider.java
index 4c7f857..d632dae 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelValueItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/provider/TransportRelationshipLabelValueItemProvider.java
@@ -37,9 +37,7 @@
  * @generated
  */
 public class TransportRelationshipLabelValueItemProvider extends
-		LabelValueItemProvider implements IEditingDomainItemProvider,
-		IStructuredItemContentProvider, ITreeItemContentProvider,
-		IItemLabelProvider, IItemPropertySource {
+		LabelValueItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier. <!--
 	 * begin-user-doc --> <!-- end-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsAdapterFactory.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsAdapterFactory.java
index dfd277d..04b4ecd 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsAdapterFactory.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsAdapterFactory.java
@@ -27,6 +27,7 @@
 import org.eclipse.stem.core.graph.StaticLabel;
 import org.eclipse.stem.core.graph.StaticNodeLabel;
 import org.eclipse.stem.core.modifier.Modifiable;
+import org.eclipse.stem.definitions.labels.*;
 import org.eclipse.stem.definitions.labels.AreaLabel;
 import org.eclipse.stem.definitions.labels.AreaLabelValue;
 import org.eclipse.stem.definitions.labels.CommonBorderRelationshipLabel;
@@ -168,6 +169,30 @@
 				return createEarthScienceLabelValueAdapter();
 			}
 			@Override
+			public <T> Adapter caseGenericLabelValue(GenericLabelValue<T> object) {
+				return createGenericLabelValueAdapter();
+			}
+			@Override
+			public Adapter caseDoubleLabelValue(DoubleLabelValue object) {
+				return createDoubleLabelValueAdapter();
+			}
+			@Override
+			public Adapter caseIntegerLabelValue(IntegerLabelValue object) {
+				return createIntegerLabelValueAdapter();
+			}
+			@Override
+			public Adapter caseLongLabelValue(LongLabelValue object) {
+				return createLongLabelValueAdapter();
+			}
+			@Override
+			public Adapter caseStringLabelValue(StringLabelValue object) {
+				return createStringLabelValueAdapter();
+			}
+			@Override
+			public Adapter caseKeyValueLabelValue(KeyValueLabelValue object) {
+				return createKeyValueLabelValueAdapter();
+			}
+			@Override
 			public <T> Adapter caseComparable(Comparable<T> object) {
 				return createComparableAdapter();
 			}
@@ -455,6 +480,90 @@
 	}
 
 	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.stem.definitions.labels.GenericLabelValue <em>Generic Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.stem.definitions.labels.GenericLabelValue
+	 * @generated
+	 */
+	public Adapter createGenericLabelValueAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.stem.definitions.labels.DoubleLabelValue <em>Double Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.stem.definitions.labels.DoubleLabelValue
+	 * @generated
+	 */
+	public Adapter createDoubleLabelValueAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.stem.definitions.labels.IntegerLabelValue <em>Integer Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.stem.definitions.labels.IntegerLabelValue
+	 * @generated
+	 */
+	public Adapter createIntegerLabelValueAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.stem.definitions.labels.LongLabelValue <em>Long Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.stem.definitions.labels.LongLabelValue
+	 * @generated
+	 */
+	public Adapter createLongLabelValueAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.stem.definitions.labels.StringLabelValue <em>String Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.stem.definitions.labels.StringLabelValue
+	 * @generated
+	 */
+	public Adapter createStringLabelValueAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.stem.definitions.labels.KeyValueLabelValue <em>Key Value Label Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.stem.definitions.labels.KeyValueLabelValue
+	 * @generated
+	 */
+	public Adapter createKeyValueLabelValueAdapter() {
+		return null;
+	}
+
+	/**
 	 * Creates a new adapter for an object of class '{@link java.lang.Comparable <em>Comparable</em>}'.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null so that we can easily ignore cases;
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsSwitch.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsSwitch.java
index 5b3239a..aaea53d 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsSwitch.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/labels/util/LabelsSwitch.java
@@ -15,6 +15,8 @@
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
 import org.eclipse.stem.core.common.Identifiable;
 import org.eclipse.stem.core.common.SanityChecker;
 import org.eclipse.stem.core.graph.DynamicEdgeLabel;
@@ -27,6 +29,7 @@
 import org.eclipse.stem.core.graph.StaticLabel;
 import org.eclipse.stem.core.graph.StaticNodeLabel;
 import org.eclipse.stem.core.modifier.Modifiable;
+import org.eclipse.stem.definitions.labels.*;
 import org.eclipse.stem.definitions.labels.AreaLabel;
 import org.eclipse.stem.definitions.labels.AreaLabelValue;
 import org.eclipse.stem.definitions.labels.CommonBorderRelationshipLabel;
@@ -55,7 +58,7 @@
  * @see org.eclipse.stem.definitions.labels.LabelsPackage
  * @generated
  */
-public class LabelsSwitch<T1> {
+public class LabelsSwitch<T1> extends Switch<T1> {
 	/**
 	 * The cached model package
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->
@@ -76,14 +79,16 @@
 	}
 
 	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * Checks whether this is a switch for the given package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @param ePackage the package in question.
+	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
-	public T1 doSwitch(EObject theEObject) {
-		return doSwitch(theEObject.eClass(), theEObject);
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
 	}
 
 	/**
@@ -93,26 +98,7 @@
 	 * @return the first non-null result returned by a <code>caseXXX</code> call.
 	 * @generated
 	 */
-	protected T1 doSwitch(EClass theEClass, EObject theEObject) {
-		if (theEClass.eContainer() == modelPackage) {
-			return doSwitch(theEClass.getClassifierID(), theEObject);
-		}
-		else {
-			List<EClass> eSuperTypes = theEClass.getESuperTypes();
-			return
-				eSuperTypes.isEmpty() ?
-					defaultCase(theEObject) :
-					doSwitch(eSuperTypes.get(0), theEObject);
-		}
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
+	@Override
 	protected T1 doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
 			case LabelsPackage.AREA_LABEL: {
@@ -295,6 +281,59 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
+			case LabelsPackage.GENERIC_LABEL_VALUE: {
+				GenericLabelValue<?> genericLabelValue = (GenericLabelValue<?>)theEObject;
+				T1 result = caseGenericLabelValue(genericLabelValue);
+				if (result == null) result = caseLabelValue(genericLabelValue);
+				if (result == null) result = caseSanityChecker(genericLabelValue);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case LabelsPackage.DOUBLE_LABEL_VALUE: {
+				DoubleLabelValue doubleLabelValue = (DoubleLabelValue)theEObject;
+				T1 result = caseDoubleLabelValue(doubleLabelValue);
+				if (result == null) result = caseGenericLabelValue(doubleLabelValue);
+				if (result == null) result = caseLabelValue(doubleLabelValue);
+				if (result == null) result = caseSanityChecker(doubleLabelValue);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case LabelsPackage.INTEGER_LABEL_VALUE: {
+				IntegerLabelValue integerLabelValue = (IntegerLabelValue)theEObject;
+				T1 result = caseIntegerLabelValue(integerLabelValue);
+				if (result == null) result = caseGenericLabelValue(integerLabelValue);
+				if (result == null) result = caseLabelValue(integerLabelValue);
+				if (result == null) result = caseSanityChecker(integerLabelValue);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case LabelsPackage.LONG_LABEL_VALUE: {
+				LongLabelValue longLabelValue = (LongLabelValue)theEObject;
+				T1 result = caseLongLabelValue(longLabelValue);
+				if (result == null) result = caseGenericLabelValue(longLabelValue);
+				if (result == null) result = caseLabelValue(longLabelValue);
+				if (result == null) result = caseSanityChecker(longLabelValue);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case LabelsPackage.STRING_LABEL_VALUE: {
+				StringLabelValue stringLabelValue = (StringLabelValue)theEObject;
+				T1 result = caseStringLabelValue(stringLabelValue);
+				if (result == null) result = caseGenericLabelValue(stringLabelValue);
+				if (result == null) result = caseLabelValue(stringLabelValue);
+				if (result == null) result = caseSanityChecker(stringLabelValue);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case LabelsPackage.KEY_VALUE_LABEL_VALUE: {
+				KeyValueLabelValue keyValueLabelValue = (KeyValueLabelValue)theEObject;
+				T1 result = caseKeyValueLabelValue(keyValueLabelValue);
+				if (result == null) result = caseGenericLabelValue(keyValueLabelValue);
+				if (result == null) result = caseLabelValue(keyValueLabelValue);
+				if (result == null) result = caseSanityChecker(keyValueLabelValue);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
 			default: return defaultCase(theEObject);
 		}
 	}
@@ -526,6 +565,96 @@
 	}
 
 	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Generic Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Generic Label Value</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public <T> T1 caseGenericLabelValue(GenericLabelValue<T> object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Double Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Double Label Value</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T1 caseDoubleLabelValue(DoubleLabelValue object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Integer Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Integer Label Value</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T1 caseIntegerLabelValue(IntegerLabelValue object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Long Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Long Label Value</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T1 caseLongLabelValue(LongLabelValue object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>String Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>String Label Value</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T1 caseStringLabelValue(StringLabelValue object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Key Value Label Value</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>Key Value Label Value</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T1 caseKeyValueLabelValue(KeyValueLabelValue object) {
+		return null;
+	}
+
+	/**
 	 * Returns the result of interpreting the object as an instance of '<em>Comparable</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
@@ -720,6 +849,7 @@
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
 	 */
+	@Override
 	public T1 defaultCase(EObject object) {
 		return null;
 	}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/GeographicFeatureImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/GeographicFeatureImpl.java
index 89f7ecb..b05c8b6 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/GeographicFeatureImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/GeographicFeatureImpl.java
@@ -20,8 +20,6 @@
  * <!-- begin-user-doc -->
  * An implementation of the model object '<em><b>Geographic Feature</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/NodesFactoryImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/NodesFactoryImpl.java
index 90336bd..3697ea2 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/NodesFactoryImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/NodesFactoryImpl.java
@@ -16,6 +16,7 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.stem.definitions.nodes.*;
 import org.eclipse.stem.definitions.nodes.NodesFactory;
 import org.eclipse.stem.definitions.nodes.NodesPackage;
 import org.eclipse.stem.definitions.nodes.Region;
@@ -35,7 +36,7 @@
 	 */
 	public static NodesFactory init() {
 		try {
-			NodesFactory theNodesFactory = (NodesFactory)EPackage.Registry.INSTANCE.getEFactory("http:///org/eclipse/stem/definitions/nodes.ecore"); //$NON-NLS-1$ 
+			NodesFactory theNodesFactory = (NodesFactory)EPackage.Registry.INSTANCE.getEFactory(NodesPackage.eNS_URI);
 			if (theNodesFactory != null) {
 				return theNodesFactory;
 			}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/RegionImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/RegionImpl.java
index b1b66a5..d1ddd46 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/RegionImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/impl/RegionImpl.java
@@ -20,8 +20,6 @@
 /**
  * <!-- begin-user-doc --> An implementation of the model object '<em><b>Region</b></em>'.
  * <!-- end-user-doc -->
- * <p>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesActionBarContributor.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesActionBarContributor.java
index 358324d..2c075b6 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesActionBarContributor.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesActionBarContributor.java
@@ -206,8 +206,7 @@
 		//
 		submenuManager.addMenuListener
 			(new IMenuListener() {
-				 @Override
-				public void menuAboutToShow(IMenuManager menuManager) {
+				 public void menuAboutToShow(IMenuManager menuManager) {
 					 menuManager.updateAll(true);
 				 }
 			 });
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesEditor.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesEditor.java
index d201fd2..dafaca6 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesEditor.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/presentation/NodesEditor.java
@@ -81,6 +81,7 @@
 import org.eclipse.jface.action.Separator;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.util.LocalSelectionTransfer;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.ISelectionChangedListener;
 import org.eclipse.jface.viewers.ISelectionProvider;
@@ -106,6 +107,7 @@
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.FileTransfer;
 import org.eclipse.swt.dnd.Transfer;
 import org.eclipse.swt.events.ControlAdapter;
 import org.eclipse.swt.events.ControlEvent;
@@ -188,7 +190,7 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
-	protected PropertySheetPage propertySheetPage;
+	protected List<PropertySheetPage> propertySheetPages = new ArrayList<PropertySheetPage>();
 
 	/**
 	 * This is the viewer that shadows the selection in the content outline.
@@ -248,7 +250,6 @@
 	 */
 	protected IPartListener partListener =
 		new IPartListener() {
-			@Override
 			public void partActivated(IWorkbenchPart p) {
 				if (p instanceof ContentOutline) {
 					if (((ContentOutline)p).getCurrentPage() == contentOutlinePage) {
@@ -258,7 +259,7 @@
 					}
 				}
 				else if (p instanceof PropertySheet) {
-					if (((PropertySheet)p).getCurrentPage() == propertySheetPage) {
+					if (propertySheetPages.contains(((PropertySheet)p).getCurrentPage())) {
 						getActionBarContributor().setActiveEditor(NodesEditor.this);
 						handleActivate();
 					}
@@ -267,19 +268,15 @@
 					handleActivate();
 				}
 			}
-			@Override
 			public void partBroughtToTop(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partClosed(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partDeactivated(IWorkbenchPart p) {
 				// Ignore.
 			}
-			@Override
 			public void partOpened(IWorkbenchPart p) {
 				// Ignore.
 			}
@@ -352,8 +349,7 @@
 							if (updateProblemIndication) {
 								getSite().getShell().getDisplay().asyncExec
 									(new Runnable() {
-										 @Override
-										public void run() {
+										 public void run() {
 											 updateProblemIndication();
 										 }
 									 });
@@ -375,6 +371,15 @@
 			@Override
 			protected void unsetTarget(Resource target) {
 				basicUnsetTarget(target);
+				resourceToDiagnosticMap.remove(target);
+				if (updateProblemIndication) {
+					getSite().getShell().getDisplay().asyncExec
+						(new Runnable() {
+							 public void run() {
+								 updateProblemIndication();
+							 }
+						 });
+				}
 			}
 		};
 
@@ -386,7 +391,6 @@
 	 */
 	protected IResourceChangeListener resourceChangeListener =
 		new IResourceChangeListener() {
-			@Override
 			public void resourceChanged(IResourceChangeEvent event) {
 				IResourceDelta delta = event.getDelta();
 				try {
@@ -395,7 +399,6 @@
 						protected Collection<Resource> changedResources = new ArrayList<Resource>();
 						protected Collection<Resource> removedResources = new ArrayList<Resource>();
 
-						@Override
 						public boolean visit(IResourceDelta delta) {
 							if (delta.getResource().getType() == IResource.FILE) {
 								if (delta.getKind() == IResourceDelta.REMOVED ||
@@ -410,6 +413,7 @@
 										}
 									}
 								}
+								return false;
 							}
 
 							return true;
@@ -430,8 +434,7 @@
 					if (!visitor.getRemovedResources().isEmpty()) {
 						getSite().getShell().getDisplay().asyncExec
 							(new Runnable() {
-								 @Override
-								public void run() {
+								 public void run() {
 									 removedResources.addAll(visitor.getRemovedResources());
 									 if (!isDirty()) {
 										 getSite().getPage().closeEditor(NodesEditor.this, false);
@@ -443,8 +446,7 @@
 					if (!visitor.getChangedResources().isEmpty()) {
 						getSite().getShell().getDisplay().asyncExec
 							(new Runnable() {
-								 @Override
-								public void run() {
+								 public void run() {
 									 changedResources.addAll(visitor.getChangedResources());
 									 if (getSite().getPage().getActiveEditor() == NodesEditor.this) {
 										 handleActivate();
@@ -648,12 +650,10 @@
 		//
 		commandStack.addCommandStackListener
 			(new CommandStackListener() {
-				 @Override
-				public void commandStackChanged(final EventObject event) {
+				 public void commandStackChanged(final EventObject event) {
 					 getContainer().getDisplay().asyncExec
 						 (new Runnable() {
-							  @Override
-							public void run() {
+							  public void run() {
 								  firePropertyChange(IEditorPart.PROP_DIRTY);
 
 								  // Try to select the affected objects.
@@ -662,8 +662,14 @@
 								  if (mostRecentCommand != null) {
 									  setSelectionToViewer(mostRecentCommand.getAffectedObjects());
 								  }
-								  if (propertySheetPage != null && !propertySheetPage.getControl().isDisposed()) {
-									  propertySheetPage.refresh();
+								  for (Iterator<PropertySheetPage> i = propertySheetPages.iterator(); i.hasNext(); ) {
+									  PropertySheetPage propertySheetPage = i.next();
+									  if (propertySheetPage.getControl().isDisposed()) {
+										  i.remove();
+									  }
+									  else {
+										  propertySheetPage.refresh();
+									  }
 								  }
 							  }
 						  });
@@ -699,7 +705,6 @@
 		if (theSelection != null && !theSelection.isEmpty()) {
 			Runnable runnable =
 				new Runnable() {
-					@Override
 					public void run() {
 						// Try to select the items in the current content viewer of the editor.
 						//
@@ -777,7 +782,6 @@
 					new ISelectionChangedListener() {
 						// This just notifies those things that are affected by the section.
 						//
-						@Override
 						public void selectionChanged(SelectionChangedEvent selectionChangedEvent) {
 							setSelection(selectionChangedEvent.getSelection());
 						}
@@ -833,7 +837,7 @@
 		getSite().registerContextMenu(contextMenu, new UnwrappingSelectionProvider(viewer));
 
 		int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
-		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() };
+		Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance(), LocalSelectionTransfer.getTransfer(), FileTransfer.getInstance() };
 		viewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(viewer));
 		viewer.addDropSupport(dndOperations, transfers, new EditingDomainViewerDropAdapter(editingDomain, viewer));
 	}
@@ -873,10 +877,11 @@
 	 * @generated
 	 */
 	public Diagnostic analyzeResourceProblems(Resource resource, Exception exception) {
-		if (!resource.getErrors().isEmpty() || !resource.getWarnings().isEmpty()) {
+		boolean hasErrors = !resource.getErrors().isEmpty();
+		if (hasErrors || !resource.getWarnings().isEmpty()) {
 			BasicDiagnostic basicDiagnostic =
 				new BasicDiagnostic
-					(Diagnostic.ERROR,
+					(hasErrors ? Diagnostic.ERROR : Diagnostic.WARNING,
 					 "org.eclipse.stem.definitions", //$NON-NLS-1$
 					 0,
 					 getString("_UI_CreateModelError_message", resource.getURI()), //$NON-NLS-1$
@@ -932,8 +937,7 @@
 
 			getSite().getShell().getDisplay().asyncExec
 				(new Runnable() {
-					 @Override
-					public void run() {
+					 public void run() {
 						 setActivePage(0);
 					 }
 				 });
@@ -957,8 +961,7 @@
 
 		getSite().getShell().getDisplay().asyncExec
 			(new Runnable() {
-				 @Override
-				public void run() {
+				 public void run() {
 					 updateProblemIndication();
 				 }
 			 });
@@ -1093,8 +1096,7 @@
 				(new ISelectionChangedListener() {
 					 // This ensures that we handle selections correctly.
 					 //
-					 @Override
-					public void selectionChanged(SelectionChangedEvent event) {
+					 public void selectionChanged(SelectionChangedEvent event) {
 						 handleContentOutlineSelection(event.getSelection());
 					 }
 				 });
@@ -1110,23 +1112,22 @@
 	 * @generated
 	 */
 	public IPropertySheetPage getPropertySheetPage() {
-		if (propertySheetPage == null) {
-			propertySheetPage =
-				new ExtendedPropertySheetPage(editingDomain) {
-					@Override
-					public void setSelectionToViewer(List<?> selection) {
-						NodesEditor.this.setSelectionToViewer(selection);
-						NodesEditor.this.setFocus();
-					}
+		PropertySheetPage propertySheetPage =
+			new ExtendedPropertySheetPage(editingDomain) {
+				@Override
+				public void setSelectionToViewer(List<?> selection) {
+					NodesEditor.this.setSelectionToViewer(selection);
+					NodesEditor.this.setFocus();
+				}
 
-					@Override
-					public void setActionBars(IActionBars actionBars) {
-						super.setActionBars(actionBars);
-						getActionBarContributor().shareGlobalActions(this, actionBars);
-					}
-				};
-			propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
-		}
+				@Override
+				public void setActionBars(IActionBars actionBars) {
+					super.setActionBars(actionBars);
+					getActionBarContributor().shareGlobalActions(this, actionBars);
+				}
+			};
+		propertySheetPage.setPropertySourceProvider(new AdapterFactoryContentProvider(adapterFactory));
+		propertySheetPages.add(propertySheetPage);
 
 		return propertySheetPage;
 	}
@@ -1181,6 +1182,7 @@
 		//
 		final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
 		saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
+		saveOptions.put(Resource.OPTION_LINE_DELIMITER, Resource.OPTION_LINE_DELIMITER_UNSPECIFIED);
 
 		// Do the work within an operation because this is a long running activity that modifies the workbench.
 		//
@@ -1233,7 +1235,7 @@
 
 	/**
 	 * This returns whether something has been persisted to the URI of the specified resource.
-	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream. 
+	 * The implementation uses the URI converter from the editor's resource set to try to open an input stream.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
@@ -1306,20 +1308,9 @@
 	 */
 	@Override
 	public void gotoMarker(IMarker marker) {
-		try {
-			if (marker.getType().equals(EValidator.MARKER)) {
-				String uriAttribute = marker.getAttribute(EValidator.URI_ATTRIBUTE, null);
-				if (uriAttribute != null) {
-					URI uri = URI.createURI(uriAttribute);
-					EObject eObject = editingDomain.getResourceSet().getEObject(uri, true);
-					if (eObject != null) {
-					  setSelectionToViewer(Collections.singleton(editingDomain.getWrapper(eObject)));
-					}
-				}
-			}
-		}
-		catch (CoreException exception) {
-			DefinitionsEditPlugin.INSTANCE.log(exception);
+		List<?> targetObjects = markerHelper.getTargetObjects(editingDomain, marker);
+		if (!targetObjects.isEmpty()) {
+			setSelectionToViewer(targetObjects);
 		}
 	}
 
@@ -1510,7 +1501,7 @@
 			getActionBarContributor().setActiveEditor(null);
 		}
 
-		if (propertySheetPage != null) {
+		for (PropertySheetPage propertySheetPage : propertySheetPages) {
 			propertySheetPage.dispose();
 		}
 
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/GeographicFeatureItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/GeographicFeatureItemProvider.java
index 2891d5a..b5c6fa4 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/GeographicFeatureItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/GeographicFeatureItemProvider.java
@@ -35,13 +35,7 @@
  * @generated
  */
 public class GeographicFeatureItemProvider
-	extends NodeItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends NodeItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/RegionItemProvider.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/RegionItemProvider.java
index 6c558b5..9974558 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/RegionItemProvider.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/provider/RegionItemProvider.java
@@ -34,13 +34,7 @@
  * @generated
  */
 public class RegionItemProvider
-	extends GeographicFeatureItemProvider
-	implements	
-		IEditingDomainItemProvider,	
-		IStructuredItemContentProvider,	
-		ITreeItemContentProvider,	
-		IItemLabelProvider,	
-		IItemPropertySource {
+	extends GeographicFeatureItemProvider {
 	/**
 	 * This constructs an instance from a factory and a notifier.
 	 * <!-- begin-user-doc -->
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesAdapterFactory.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesAdapterFactory.java
index b75aeb9..2f5722a 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesAdapterFactory.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesAdapterFactory.java
@@ -19,6 +19,7 @@
 import org.eclipse.stem.core.common.Identifiable;
 import org.eclipse.stem.core.common.SanityChecker;
 import org.eclipse.stem.core.graph.Node;
+import org.eclipse.stem.definitions.nodes.*;
 import org.eclipse.stem.definitions.nodes.GeographicFeature;
 import org.eclipse.stem.definitions.nodes.NodesPackage;
 import org.eclipse.stem.definitions.nodes.Region;
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesSwitch.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesSwitch.java
index f93c137..42903a6 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesSwitch.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/nodes/util/NodesSwitch.java
@@ -15,9 +15,12 @@
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
 import org.eclipse.stem.core.common.Identifiable;
 import org.eclipse.stem.core.common.SanityChecker;
 import org.eclipse.stem.core.graph.Node;
+import org.eclipse.stem.definitions.nodes.*;
 import org.eclipse.stem.definitions.nodes.GeographicFeature;
 import org.eclipse.stem.definitions.nodes.NodesPackage;
 import org.eclipse.stem.definitions.nodes.Region;
@@ -35,7 +38,7 @@
  * @see org.eclipse.stem.definitions.nodes.NodesPackage
  * @generated
  */
-public class NodesSwitch<T1> {
+public class NodesSwitch<T1> extends Switch<T1> {
 	/**
 	 * The cached model package
 	 * <!-- begin-user-doc -->
@@ -57,14 +60,16 @@
 	}
 
 	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * Checks whether this is a switch for the given package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @param ePackage the package in question.
+	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
-	public T1 doSwitch(EObject theEObject) {
-		return doSwitch(theEObject.eClass(), theEObject);
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
 	}
 
 	/**
@@ -74,26 +79,7 @@
 	 * @return the first non-null result returned by a <code>caseXXX</code> call.
 	 * @generated
 	 */
-	protected T1 doSwitch(EClass theEClass, EObject theEObject) {
-		if (theEClass.eContainer() == modelPackage) {
-			return doSwitch(theEClass.getClassifierID(), theEObject);
-		}
-		else {
-			List<EClass> eSuperTypes = theEClass.getESuperTypes();
-			return
-				eSuperTypes.isEmpty() ?
-					defaultCase(theEObject) :
-					doSwitch(eSuperTypes.get(0), theEObject);
-		}
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
+	@Override
 	protected T1 doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
 			case NodesPackage.GEOGRAPHIC_FEATURE: {
@@ -117,6 +103,12 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
+			case NodesPackage.NODE: {
+				Node node = (Node)theEObject;
+				T1 result = caseNode(node);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
 			default: return defaultCase(theEObject);
 		}
 	}
@@ -237,6 +229,7 @@
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
 	 */
+	@Override
 	public T1 defaultCase(EObject object) {
 		return null;
 	}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/RateImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/RateImpl.java
index b7b6834..165209e 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/RateImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/RateImpl.java
@@ -24,10 +24,10 @@
  * <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
+ * </p>
  * <ul>
  *   <li>{@link org.eclipse.stem.definitions.types.impl.RateImpl#getRate <em>Rate</em>}</li>
  * </ul>
- * </p>
  *
  * @generated
  */
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/TypesFactoryImpl.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/TypesFactoryImpl.java
index 0031e1e..25303e0 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/TypesFactoryImpl.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/impl/TypesFactoryImpl.java
@@ -16,6 +16,7 @@
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.impl.EFactoryImpl;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.stem.definitions.types.*;
 import org.eclipse.stem.definitions.types.TypesFactory;
 import org.eclipse.stem.definitions.types.TypesPackage;
 
@@ -34,7 +35,7 @@
 	 */
 	public static TypesFactory init() {
 		try {
-			TypesFactory theTypesFactory = (TypesFactory)EPackage.Registry.INSTANCE.getEFactory("http:///org/eclipse/stem/definitions/types.ecore"); //$NON-NLS-1$ 
+			TypesFactory theTypesFactory = (TypesFactory)EPackage.Registry.INSTANCE.getEFactory(TypesPackage.eNS_URI);
 			if (theTypesFactory != null) {
 				return theTypesFactory;
 			}
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesAdapterFactory.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesAdapterFactory.java
index a825f24..f921ac8 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesAdapterFactory.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesAdapterFactory.java
@@ -15,6 +15,7 @@
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.stem.definitions.types.*;
 import org.eclipse.stem.definitions.types.CategorizedType;
 import org.eclipse.stem.definitions.types.Rate;
 import org.eclipse.stem.definitions.types.TypesPackage;
diff --git a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesSwitch.java b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesSwitch.java
index 3b28594..a086b3d 100644
--- a/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesSwitch.java
+++ b/core/org.eclipse.stem.definitions/src/org/eclipse/stem/definitions/types/util/TypesSwitch.java
@@ -15,6 +15,9 @@
 
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.stem.definitions.types.*;
 import org.eclipse.stem.definitions.types.CategorizedType;
 import org.eclipse.stem.definitions.types.Rate;
 import org.eclipse.stem.definitions.types.TypesPackage;
@@ -32,7 +35,7 @@
  * @see org.eclipse.stem.definitions.types.TypesPackage
  * @generated
  */
-public class TypesSwitch<T> {
+public class TypesSwitch<T> extends Switch<T> {
 	/**
 	 * The cached model package
 	 * <!-- begin-user-doc -->
@@ -54,14 +57,16 @@
 	}
 
 	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * Checks whether this is a switch for the given package.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @param ePackage the package in question.
+	 * @return whether this is a switch for the given package.
 	 * @generated
 	 */
-	public T doSwitch(EObject theEObject) {
-		return doSwitch(theEObject.eClass(), theEObject);
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
 	}
 
 	/**
@@ -71,26 +76,7 @@
 	 * @return the first non-null result returned by a <code>caseXXX</code> call.
 	 * @generated
 	 */
-	protected T doSwitch(EClass theEClass, EObject theEObject) {
-		if (theEClass.eContainer() == modelPackage) {
-			return doSwitch(theEClass.getClassifierID(), theEObject);
-		}
-		else {
-			List<EClass> eSuperTypes = theEClass.getESuperTypes();
-			return
-				eSuperTypes.isEmpty() ?
-					defaultCase(theEObject) :
-					doSwitch(eSuperTypes.get(0), theEObject);
-		}
-	}
-
-	/**
-	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the first non-null result returned by a <code>caseXXX</code> call.
-	 * @generated
-	 */
+	@Override
 	protected T doSwitch(int classifierID, EObject theEObject) {
 		switch (classifierID) {
 			case TypesPackage.CATEGORIZED_TYPE: {
@@ -150,6 +136,7 @@
 	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
 	 * @generated
 	 */
+	@Override
 	public T defaultCase(EObject object) {
 		return null;
 	}
