diff --git a/org.eclipse.rmf.ext.prostep/build.properties b/org.eclipse.rmf.ext.prostep/build.properties
index bff842c..a0e9e73 100644
--- a/org.eclipse.rmf.ext.prostep/build.properties
+++ b/org.eclipse.rmf.ext.prostep/build.properties
@@ -12,11 +12,7 @@
                model/,\
                META-INF/,\
                plugin.xml,\
-               plugin.properties,\
-               about.html,\
-               about.properties,\
-               epl-v10.html,\
-               notice.html
+               plugin.properties
 jars.compile.order = .
 source.. = src/
 output.. = bin/
diff --git a/org.eclipse.rmf.ext.prostep/model/prostep.genmodel b/org.eclipse.rmf.ext.prostep/model/prostep.genmodel
index d6c04c7..6cb9bc7 100644
--- a/org.eclipse.rmf.ext.prostep/model/prostep.genmodel
+++ b/org.eclipse.rmf.ext.prostep/model/prostep.genmodel
@@ -6,8 +6,8 @@
     testsDirectory="" importerID="org.eclipse.emf.importer.ecore" complianceLevel="5.0"
     copyrightFields="false" language="" operationReflection="true" importOrganizing="true">
   <foreignModel>prostep.ecore</foreignModel>
-  <genPackages prefix="Prostep" basePackage="org.eclipse.rmf.ext" resource="XML" disposableProviderFactory="true"
-      ecorePackage="prostep.ecore#/">
+  <genPackages prefix="Prostep" basePackage="org.eclipse.rmf.ext" disposableProviderFactory="true"
+      fileExtensions="" ecorePackage="prostep.ecore#/">
     <genClasses ecoreClass="prostep.ecore#//ExchangeConversation">
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute prostep.ecore#//ExchangeConversation/identifier"/>
     </genClasses>
diff --git a/org.eclipse.rmf.ext.prostep/plugin.xml b/org.eclipse.rmf.ext.prostep/plugin.xml
index b064b2e..0050c96 100644
--- a/org.eclipse.rmf.ext.prostep/plugin.xml
+++ b/org.eclipse.rmf.ext.prostep/plugin.xml
@@ -23,11 +23,4 @@
             genModel="model/prostep.genmodel"/>
    </extension>
 
-   <extension point="org.eclipse.emf.ecore.extension_parser">
-      <!-- @generated prostep -->
-      <parser
-            type="prostep"
-            class="org.eclipse.rmf.ext.prostep.util.ProstepResourceFactoryImpl"/>
-   </extension>
-
 </plugin>
diff --git a/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepResourceFactoryImpl.java b/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepResourceFactoryImpl.java
deleted file mode 100644
index 1c03a0a..0000000
--- a/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepResourceFactoryImpl.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/**
- * Copyright (c) 2014 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.ext.prostep.util;
-
-import org.eclipse.emf.common.util.URI;
-
-import org.eclipse.emf.ecore.resource.Resource;
-
-import org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl;
-
-import org.eclipse.emf.ecore.xmi.XMLResource;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource Factory</b> associated with the package.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.ext.prostep.util.ProstepResourceImpl
- * @generated
- */
-public class ProstepResourceFactoryImpl extends ResourceFactoryImpl {
-	/**
-	 * Creates an instance of the resource factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProstepResourceFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * Creates an instance of the resource.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Resource createResource(URI uri) {
-		XMLResource result = new ProstepResourceImpl(uri);
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
-
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_SCHEMA_LOCATION, Boolean.TRUE);
-
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_USE_LEXICAL_HANDLER, Boolean.TRUE);
-		return result;
-	}
-
-} //ProstepResourceFactoryImpl
diff --git a/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepResourceImpl.java b/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepResourceImpl.java
deleted file mode 100644
index 9eee499..0000000
--- a/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepResourceImpl.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Copyright (c) 2014 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.ext.prostep.util;
-
-import org.eclipse.emf.common.util.URI;
-
-import org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource </b> associated with the package.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.ext.prostep.util.ProstepResourceFactoryImpl
- * @generated
- */
-public class ProstepResourceImpl extends XMLResourceImpl {
-	/**
-	 * Creates an instance of the resource.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param uri the URI of the new resource.
-	 * @generated
-	 */
-	public ProstepResourceImpl(URI uri) {
-		super(uri);
-	}
-
-} //ProstepResourceImpl
diff --git a/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepXMLProcessor.java b/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepXMLProcessor.java
deleted file mode 100644
index e432912..0000000
--- a/org.eclipse.rmf.ext.prostep/src/org/eclipse/rmf/ext/prostep/util/ProstepXMLProcessor.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * Copyright (c) 2014 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.ext.prostep.util;
-
-import java.util.Map;
-
-import org.eclipse.emf.ecore.EPackage;
-
-import org.eclipse.emf.ecore.resource.Resource;
-
-import org.eclipse.emf.ecore.xmi.util.XMLProcessor;
-
-import org.eclipse.rmf.ext.prostep.ProstepPackage;
-
-/**
- * This class contains helper methods to serialize and deserialize XML documents
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ProstepXMLProcessor extends XMLProcessor {
-
-	/**
-	 * Public constructor to instantiate the helper.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProstepXMLProcessor() {
-		super((EPackage.Registry.INSTANCE));
-		ProstepPackage.eINSTANCE.eClass();
-	}
-	
-	/**
-	 * Register for "*" and "xml" file extensions the ProstepResourceFactoryImpl factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected Map<String, Resource.Factory> getRegistrations() {
-		if (registrations == null) {
-			super.getRegistrations();
-			registrations.put(XML_EXTENSION, new ProstepResourceFactoryImpl());
-			registrations.put(STAR_EXTENSION, new ProstepResourceFactoryImpl());
-		}
-		return registrations;
-	}
-
-} //ProstepXMLProcessor
diff --git a/org.eclipse.rmf.reqif10.pror/model/reqif10.genmodel b/org.eclipse.rmf.reqif10.pror/model/reqif10.genmodel
index d5d0c15..e2ea888 100644
--- a/org.eclipse.rmf.reqif10.pror/model/reqif10.genmodel
+++ b/org.eclipse.rmf.reqif10.pror/model/reqif10.genmodel
@@ -6,8 +6,8 @@
     usedGenPackages="platform:/plugin/org.eclipse.emf.ecore/model/XMLNamespace.genmodel#//namespace"
     importOrganizing="true">
   <foreignModel>configuration.ecore</foreignModel>
-  <genPackages prefix="Configuration" basePackage="org.eclipse.rmf.reqif10.pror" resource="XML"
-      disposableProviderFactory="true" ecorePackage="configuration.ecore#/">
+  <genPackages prefix="Configuration" basePackage="org.eclipse.rmf.reqif10.pror" disposableProviderFactory="true"
+      fileExtensions="" ecorePackage="configuration.ecore#/">
     <genClasses image="false" ecoreClass="configuration.ecore#//ProrToolExtension">
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference configuration.ecore#//ProrToolExtension/specViewConfigurations"/>
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference configuration.ecore#//ProrToolExtension/generalConfiguration"/>
@@ -36,8 +36,8 @@
     </genClasses>
     <genClasses image="false" ecoreClass="configuration.ecore#//UnifiedColumn"/>
   </genPackages>
-  <genPackages prefix="ReqIF10" basePackage="org.eclipse.rmf" resource="XML" disposableProviderFactory="true"
-      providerPackageSuffix="pror.provider" ecorePackage="../../org.eclipse.rmf.reqif10/model/reqif10.ecore#/">
+  <genPackages prefix="ReqIF10" basePackage="org.eclipse.rmf" disposableProviderFactory="true"
+      providerPackageSuffix="pror.provider" fileExtensions="" ecorePackage="../../org.eclipse.rmf.reqif10/model/reqif10.ecore#/">
     <genDataTypes ecoreDataType="../../org.eclipse.rmf.reqif10/model/reqif10.ecore#//DateTime"/>
     <genDataTypes ecoreDataType="../../org.eclipse.rmf.reqif10/model/reqif10.ecore#//ID"/>
     <genClasses image="false" ecoreClass="../../org.eclipse.rmf.reqif10/model/reqif10.ecore#//AccessControlledElement">
diff --git a/org.eclipse.rmf.reqif10.pror/plugin.xml b/org.eclipse.rmf.reqif10.pror/plugin.xml
index 7418746..3572a00 100644
--- a/org.eclipse.rmf.reqif10.pror/plugin.xml
+++ b/org.eclipse.rmf.reqif10.pror/plugin.xml
@@ -27,12 +27,6 @@
             genModel="model/reqif10.genmodel"/>
    </extension>
 
-   <extension point="org.eclipse.emf.ecore.extension_parser">
-      <!-- @generated reqif10 -->
-      <parser
-            type="configuration"
-            class="org.eclipse.rmf.reqif10.pror.configuration.util.ConfigurationResourceFactoryImpl"/>
-   </extension>
 
    <extension
          point="org.eclipse.ui.intro">
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/Column.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/Column.java
index 61be870..1d818f3 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/Column.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/Column.java
@@ -1,142 +1,133 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Column</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getColumn()
- * @model
- * @generated
- */
-public interface Column extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Label</b></em>' attribute.
-	 * The default value is <code>"<PLEASE SET LABEL>"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Label</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Label</em>' attribute.
-	 * @see #isSetLabel()
-	 * @see #unsetLabel()
-	 * @see #setLabel(String)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getColumn_Label()
-	 * @model default="<PLEASE SET LABEL>" unsettable="true" required="true"
-	 * @generated
-	 */
-	String getLabel();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Label</em>' attribute.
-	 * @see #isSetLabel()
-	 * @see #unsetLabel()
-	 * @see #getLabel()
-	 * @generated
-	 */
-	void setLabel(String value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetLabel()
-	 * @see #getLabel()
-	 * @see #setLabel(String)
-	 * @generated
-	 */
-	void unsetLabel();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Label</em>' attribute is set.
-	 * @see #unsetLabel()
-	 * @see #getLabel()
-	 * @see #setLabel(String)
-	 * @generated
-	 */
-	boolean isSetLabel();
-
-	/**
-	 * Returns the value of the '<em><b>Width</b></em>' attribute.
-	 * The default value is <code>"100"</code>.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Width</em>' attribute isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Width</em>' attribute.
-	 * @see #isSetWidth()
-	 * @see #unsetWidth()
-	 * @see #setWidth(int)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getColumn_Width()
-	 * @model default="100" unsettable="true" required="true"
-	 * @generated
-	 */
-	int getWidth();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Width</em>' attribute.
-	 * @see #isSetWidth()
-	 * @see #unsetWidth()
-	 * @see #getWidth()
-	 * @generated
-	 */
-	void setWidth(int value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetWidth()
-	 * @see #getWidth()
-	 * @see #setWidth(int)
-	 * @generated
-	 */
-	void unsetWidth();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}' attribute is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Width</em>' attribute is set.
-	 * @see #unsetWidth()
-	 * @see #getWidth()
-	 * @see #setWidth(int)
-	 * @generated
-	 */
-	boolean isSetWidth();
-
-} // Column
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Column</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getColumn()
+ * @model
+ * @generated
+ */
+public interface Column extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Label</b></em>' attribute.
+	 * The default value is <code>"<PLEASE SET LABEL>"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label</em>' attribute.
+	 * @see #isSetLabel()
+	 * @see #unsetLabel()
+	 * @see #setLabel(String)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getColumn_Label()
+	 * @model default="<PLEASE SET LABEL>" unsettable="true" required="true"
+	 * @generated
+	 */
+	String getLabel();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label</em>' attribute.
+	 * @see #isSetLabel()
+	 * @see #unsetLabel()
+	 * @see #getLabel()
+	 * @generated
+	 */
+	void setLabel(String value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetLabel()
+	 * @see #getLabel()
+	 * @see #setLabel(String)
+	 * @generated
+	 */
+	void unsetLabel();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}' attribute is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Label</em>' attribute is set.
+	 * @see #unsetLabel()
+	 * @see #getLabel()
+	 * @see #setLabel(String)
+	 * @generated
+	 */
+	boolean isSetLabel();
+
+	/**
+	 * Returns the value of the '<em><b>Width</b></em>' attribute.
+	 * The default value is <code>"100"</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Width</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Width</em>' attribute.
+	 * @see #isSetWidth()
+	 * @see #unsetWidth()
+	 * @see #setWidth(int)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getColumn_Width()
+	 * @model default="100" unsettable="true" required="true"
+	 * @generated
+	 */
+	int getWidth();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Width</em>' attribute.
+	 * @see #isSetWidth()
+	 * @see #unsetWidth()
+	 * @see #getWidth()
+	 * @generated
+	 */
+	void setWidth(int value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetWidth()
+	 * @see #getWidth()
+	 * @see #setWidth(int)
+	 * @generated
+	 */
+	void unsetWidth();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}' attribute is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Width</em>' attribute is set.
+	 * @see #unsetWidth()
+	 * @see #getWidth()
+	 * @see #setWidth(int)
+	 * @generated
+	 */
+	boolean isSetWidth();
+
+} // Column
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationFactory.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationFactory.java
index 7a55c4c..bd3e58c 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationFactory.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationFactory.java
@@ -1,105 +1,96 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2012 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.ecore.EFactory;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage
- * @generated
- */
-public interface ConfigurationFactory extends EFactory {
-	/**
-	 * The singleton instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	ConfigurationFactory eINSTANCE = org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationFactoryImpl.init();
-
-	/**
-	 * Returns a new object of class '<em>Pror Tool Extension</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Pror Tool Extension</em>'.
-	 * @generated
-	 */
-	ProrToolExtension createProrToolExtension();
-
-	/**
-	 * Returns a new object of class '<em>Pror Spec View Configuration</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Pror Spec View Configuration</em>'.
-	 * @generated
-	 */
-	ProrSpecViewConfiguration createProrSpecViewConfiguration();
-
-	/**
-	 * Returns a new object of class '<em>Column</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Column</em>'.
-	 * @generated
-	 */
-	Column createColumn();
-
-	/**
-	 * Returns a new object of class '<em>Pror Presentation Configurations</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Pror Presentation Configurations</em>'.
-	 * @generated
-	 */
-	ProrPresentationConfigurations createProrPresentationConfigurations();
-
-	/**
-	 * Returns a new object of class '<em>Pror General Configuration</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Pror General Configuration</em>'.
-	 * @generated
-	 */
-	ProrGeneralConfiguration createProrGeneralConfiguration();
-
-	/**
-	 * Returns a new object of class '<em>Label Configuration</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Label Configuration</em>'.
-	 * @generated
-	 */
-	LabelConfiguration createLabelConfiguration();
-
-	/**
-	 * Returns a new object of class '<em>Unified Column</em>'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return a new object of class '<em>Unified Column</em>'.
-	 * @generated
-	 */
-	UnifiedColumn createUnifiedColumn();
-
-	/**
-	 * Returns the package supported by this factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the package supported by this factory.
-	 * @generated
-	 */
-	ConfigurationPackage getConfigurationPackage();
-
-} //ConfigFactory
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage
+ * @generated
+ */
+public interface ConfigurationFactory extends EFactory {
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	ConfigurationFactory eINSTANCE = org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>Pror Tool Extension</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Pror Tool Extension</em>'.
+	 * @generated
+	 */
+	ProrToolExtension createProrToolExtension();
+
+	/**
+	 * Returns a new object of class '<em>Pror Spec View Configuration</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Pror Spec View Configuration</em>'.
+	 * @generated
+	 */
+	ProrSpecViewConfiguration createProrSpecViewConfiguration();
+
+	/**
+	 * Returns a new object of class '<em>Column</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Column</em>'.
+	 * @generated
+	 */
+	Column createColumn();
+
+	/**
+	 * Returns a new object of class '<em>Pror Presentation Configurations</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Pror Presentation Configurations</em>'.
+	 * @generated
+	 */
+	ProrPresentationConfigurations createProrPresentationConfigurations();
+
+	/**
+	 * Returns a new object of class '<em>Pror General Configuration</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Pror General Configuration</em>'.
+	 * @generated
+	 */
+	ProrGeneralConfiguration createProrGeneralConfiguration();
+
+	/**
+	 * Returns a new object of class '<em>Label Configuration</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Label Configuration</em>'.
+	 * @generated
+	 */
+	LabelConfiguration createLabelConfiguration();
+
+	/**
+	 * Returns a new object of class '<em>Unified Column</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>Unified Column</em>'.
+	 * @generated
+	 */
+	UnifiedColumn createUnifiedColumn();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	ConfigurationPackage getConfigurationPackage();
+
+} //ConfigurationFactory
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationPackage.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationPackage.java
index 15d2f63..61b1118 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationPackage.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ConfigurationPackage.java
@@ -1,759 +1,749 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
- * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
- * </ul>
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationFactory
- * @model kind="package"
- * @generated
- */
-public interface ConfigurationPackage extends EPackage {
-	/**
-	 * The package name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNAME = "configuration";
-
-	/**
-	 * The package namespace URI.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_URI = "http://eclipse.org/rmf/pror/toolextensions/1.0";
-
-	/**
-	 * The package namespace name.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	String eNS_PREFIX = "configuration";
-
-	/**
-	 * The singleton instance of the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	ConfigurationPackage eINSTANCE = org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl.init();
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl <em>Pror Tool Extension</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrToolExtension()
-	 * @generated
-	 */
-	int PROR_TOOL_EXTENSION = 0;
-
-	/**
-	 * The feature id for the '<em><b>Spec View Configurations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS = 0;
-
-	/**
-	 * The feature id for the '<em><b>General Configuration</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION = 1;
-
-	/**
-	 * The feature id for the '<em><b>Presentation Configurations</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS = 2;
-
-	/**
-	 * The number of structural features of the '<em>Pror Tool Extension</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_TOOL_EXTENSION_FEATURE_COUNT = 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl <em>Pror Spec View Configuration</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrSpecViewConfiguration()
-	 * @generated
-	 */
-	int PROR_SPEC_VIEW_CONFIGURATION = 1;
-
-	/**
-	 * The feature id for the '<em><b>Specification</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION = 0;
-
-	/**
-	 * The feature id for the '<em><b>Columns</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_SPEC_VIEW_CONFIGURATION__COLUMNS = 1;
-
-	/**
-	 * The feature id for the '<em><b>Left Header Column</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN = 2;
-
-	/**
-	 * The number of structural features of the '<em>Pror Spec View Configuration</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_SPEC_VIEW_CONFIGURATION_FEATURE_COUNT = 3;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl <em>Column</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getColumn()
-	 * @generated
-	 */
-	int COLUMN = 2;
-
-	/**
-	 * The feature id for the '<em><b>Label</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COLUMN__LABEL = 0;
-
-	/**
-	 * The feature id for the '<em><b>Width</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COLUMN__WIDTH = 1;
-
-	/**
-	 * The number of structural features of the '<em>Column</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int COLUMN_FEATURE_COUNT = 2;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl <em>Pror Presentation Configurations</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfigurations()
-	 * @generated
-	 */
-	int PROR_PRESENTATION_CONFIGURATIONS = 3;
-
-	/**
-	 * The feature id for the '<em><b>Presentation Configurations</b></em>' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS = 0;
-
-	/**
-	 * The number of structural features of the '<em>Pror Presentation Configurations</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_PRESENTATION_CONFIGURATIONS_FEATURE_COUNT = 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl <em>Pror Presentation Configuration</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfiguration()
-	 * @generated
-	 */
-	int PROR_PRESENTATION_CONFIGURATION = 4;
-
-	/**
-	 * The feature id for the '<em><b>Datatype</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_PRESENTATION_CONFIGURATION__DATATYPE = 0;
-
-	/**
-	 * The number of structural features of the '<em>Pror Presentation Configuration</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_PRESENTATION_CONFIGURATION_FEATURE_COUNT = 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl <em>Pror General Configuration</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrGeneralConfiguration()
-	 * @generated
-	 */
-	int PROR_GENERAL_CONFIGURATION = 5;
-
-	/**
-	 * The feature id for the '<em><b>Label Configuration</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION = 0;
-
-	/**
-	 * The number of structural features of the '<em>Pror General Configuration</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int PROR_GENERAL_CONFIGURATION_FEATURE_COUNT = 1;
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl <em>Label Configuration</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getLabelConfiguration()
-	 * @generated
-	 */
-	int LABEL_CONFIGURATION = 6;
-
-	/**
-	 * The feature id for the '<em><b>Default Label</b></em>' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LABEL_CONFIGURATION__DEFAULT_LABEL = 0;
-
-	/**
-	 * The number of structural features of the '<em>Label Configuration</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int LABEL_CONFIGURATION_FEATURE_COUNT = 1;
-
-
-	/**
-	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl <em>Unified Column</em>}' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getUnifiedColumn()
-	 * @generated
-	 */
-	int UNIFIED_COLUMN = 7;
-
-	/**
-	 * The feature id for the '<em><b>Label</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UNIFIED_COLUMN__LABEL = COLUMN__LABEL;
-
-	/**
-	 * The feature id for the '<em><b>Width</b></em>' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UNIFIED_COLUMN__WIDTH = COLUMN__WIDTH;
-
-	/**
-	 * The number of structural features of the '<em>Unified Column</em>' class.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	int UNIFIED_COLUMN_FEATURE_COUNT = COLUMN_FEATURE_COUNT + 0;
-
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension <em>Pror Tool Extension</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Pror Tool Extension</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension
-	 * @generated
-	 */
-	EClass getProrToolExtension();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Spec View Configurations</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations()
-	 * @see #getProrToolExtension()
-	 * @generated
-	 */
-	EReference getProrToolExtension_SpecViewConfigurations();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>General Configuration</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration()
-	 * @see #getProrToolExtension()
-	 * @generated
-	 */
-	EReference getProrToolExtension_GeneralConfiguration();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Presentation Configurations</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations()
-	 * @see #getProrToolExtension()
-	 * @generated
-	 */
-	EReference getProrToolExtension_PresentationConfigurations();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration <em>Pror Spec View Configuration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Pror Spec View Configuration</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration
-	 * @generated
-	 */
-	EClass getProrSpecViewConfiguration();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Specification</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification()
-	 * @see #getProrSpecViewConfiguration()
-	 * @generated
-	 */
-	EReference getProrSpecViewConfiguration_Specification();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Columns</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns()
-	 * @see #getProrSpecViewConfiguration()
-	 * @generated
-	 */
-	EReference getProrSpecViewConfiguration_Columns();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Left Header Column</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn()
-	 * @see #getProrSpecViewConfiguration()
-	 * @generated
-	 */
-	EReference getProrSpecViewConfiguration_LeftHeaderColumn();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.Column <em>Column</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Column</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.Column
-	 * @generated
-	 */
-	EClass getColumn();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Label</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel()
-	 * @see #getColumn()
-	 * @generated
-	 */
-	EAttribute getColumn_Label();
-
-	/**
-	 * Returns the meta object for the attribute '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute '<em>Width</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth()
-	 * @see #getColumn()
-	 * @generated
-	 */
-	EAttribute getColumn_Width();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations <em>Pror Presentation Configurations</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Pror Presentation Configurations</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations
-	 * @generated
-	 */
-	EClass getProrPresentationConfigurations();
-
-	/**
-	 * Returns the meta object for the containment reference list '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference list '<em>Presentation Configurations</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations()
-	 * @see #getProrPresentationConfigurations()
-	 * @generated
-	 */
-	EReference getProrPresentationConfigurations_PresentationConfigurations();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration <em>Pror Presentation Configuration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Pror Presentation Configuration</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration
-	 * @generated
-	 */
-	EClass getProrPresentationConfiguration();
-
-	/**
-	 * Returns the meta object for the reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the reference '<em>Datatype</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype()
-	 * @see #getProrPresentationConfiguration()
-	 * @generated
-	 */
-	EReference getProrPresentationConfiguration_Datatype();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration <em>Pror General Configuration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Pror General Configuration</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration
-	 * @generated
-	 */
-	EClass getProrGeneralConfiguration();
-
-	/**
-	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the containment reference '<em>Label Configuration</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration()
-	 * @see #getProrGeneralConfiguration()
-	 * @generated
-	 */
-	EReference getProrGeneralConfiguration_LabelConfiguration();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration <em>Label Configuration</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Label Configuration</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration
-	 * @generated
-	 */
-	EClass getLabelConfiguration();
-
-	/**
-	 * Returns the meta object for the attribute list '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for the attribute list '<em>Default Label</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel()
-	 * @see #getLabelConfiguration()
-	 * @generated
-	 */
-	EAttribute getLabelConfiguration_DefaultLabel();
-
-	/**
-	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn <em>Unified Column</em>}'.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the meta object for class '<em>Unified Column</em>'.
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn
-	 * @generated
-	 */
-	EClass getUnifiedColumn();
-
-	/**
-	 * Returns the factory that creates the instances of the model.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return the factory that creates the instances of the model.
-	 * @generated
-	 */
-	ConfigurationFactory getConfigurationFactory();
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * Defines literals for the meta objects that represent
-	 * <ul>
-	 *   <li>each class,</li>
-	 *   <li>each feature of each class,</li>
-	 *   <li>each enum,</li>
-	 *   <li>and each data type</li>
-	 * </ul>
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	interface Literals {
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl <em>Pror Tool Extension</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrToolExtension()
-		 * @generated
-		 */
-		EClass PROR_TOOL_EXTENSION = eINSTANCE.getProrToolExtension();
-
-		/**
-		 * The meta object literal for the '<em><b>Spec View Configurations</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS = eINSTANCE.getProrToolExtension_SpecViewConfigurations();
-
-		/**
-		 * The meta object literal for the '<em><b>General Configuration</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION = eINSTANCE.getProrToolExtension_GeneralConfiguration();
-
-		/**
-		 * The meta object literal for the '<em><b>Presentation Configurations</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS = eINSTANCE.getProrToolExtension_PresentationConfigurations();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl <em>Pror Spec View Configuration</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrSpecViewConfiguration()
-		 * @generated
-		 */
-		EClass PROR_SPEC_VIEW_CONFIGURATION = eINSTANCE.getProrSpecViewConfiguration();
-
-		/**
-		 * The meta object literal for the '<em><b>Specification</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION = eINSTANCE.getProrSpecViewConfiguration_Specification();
-
-		/**
-		 * The meta object literal for the '<em><b>Columns</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_SPEC_VIEW_CONFIGURATION__COLUMNS = eINSTANCE.getProrSpecViewConfiguration_Columns();
-
-		/**
-		 * The meta object literal for the '<em><b>Left Header Column</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN = eINSTANCE.getProrSpecViewConfiguration_LeftHeaderColumn();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl <em>Column</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getColumn()
-		 * @generated
-		 */
-		EClass COLUMN = eINSTANCE.getColumn();
-
-		/**
-		 * The meta object literal for the '<em><b>Label</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute COLUMN__LABEL = eINSTANCE.getColumn_Label();
-
-		/**
-		 * The meta object literal for the '<em><b>Width</b></em>' attribute feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute COLUMN__WIDTH = eINSTANCE.getColumn_Width();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl <em>Pror Presentation Configurations</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfigurations()
-		 * @generated
-		 */
-		EClass PROR_PRESENTATION_CONFIGURATIONS = eINSTANCE.getProrPresentationConfigurations();
-
-		/**
-		 * The meta object literal for the '<em><b>Presentation Configurations</b></em>' containment reference list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS = eINSTANCE.getProrPresentationConfigurations_PresentationConfigurations();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl <em>Pror Presentation Configuration</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfiguration()
-		 * @generated
-		 */
-		EClass PROR_PRESENTATION_CONFIGURATION = eINSTANCE.getProrPresentationConfiguration();
-
-		/**
-		 * The meta object literal for the '<em><b>Datatype</b></em>' reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_PRESENTATION_CONFIGURATION__DATATYPE = eINSTANCE.getProrPresentationConfiguration_Datatype();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl <em>Pror General Configuration</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrGeneralConfiguration()
-		 * @generated
-		 */
-		EClass PROR_GENERAL_CONFIGURATION = eINSTANCE.getProrGeneralConfiguration();
-
-		/**
-		 * The meta object literal for the '<em><b>Label Configuration</b></em>' containment reference feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EReference PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION = eINSTANCE.getProrGeneralConfiguration_LabelConfiguration();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl <em>Label Configuration</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getLabelConfiguration()
-		 * @generated
-		 */
-		EClass LABEL_CONFIGURATION = eINSTANCE.getLabelConfiguration();
-
-		/**
-		 * The meta object literal for the '<em><b>Default Label</b></em>' attribute list feature.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @generated
-		 */
-		EAttribute LABEL_CONFIGURATION__DEFAULT_LABEL = eINSTANCE.getLabelConfiguration_DefaultLabel();
-
-		/**
-		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl <em>Unified Column</em>}' class.
-		 * <!-- begin-user-doc -->
-		 * <!-- end-user-doc -->
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl
-		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getUnifiedColumn()
-		 * @generated
-		 */
-		EClass UNIFIED_COLUMN = eINSTANCE.getUnifiedColumn();
-
-	}
-
-} //ConfigPackage
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface ConfigurationPackage extends EPackage {
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "configuration";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://eclipse.org/rmf/pror/toolextensions/1.0";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "configuration";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	ConfigurationPackage eINSTANCE = org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl <em>Pror Tool Extension</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrToolExtension()
+	 * @generated
+	 */
+	int PROR_TOOL_EXTENSION = 0;
+
+	/**
+	 * The feature id for the '<em><b>Spec View Configurations</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS = 0;
+
+	/**
+	 * The feature id for the '<em><b>General Configuration</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION = 1;
+
+	/**
+	 * The feature id for the '<em><b>Presentation Configurations</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS = 2;
+
+	/**
+	 * The number of structural features of the '<em>Pror Tool Extension</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_TOOL_EXTENSION_FEATURE_COUNT = 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl <em>Pror Spec View Configuration</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrSpecViewConfiguration()
+	 * @generated
+	 */
+	int PROR_SPEC_VIEW_CONFIGURATION = 1;
+
+	/**
+	 * The feature id for the '<em><b>Specification</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION = 0;
+
+	/**
+	 * The feature id for the '<em><b>Columns</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_SPEC_VIEW_CONFIGURATION__COLUMNS = 1;
+
+	/**
+	 * The feature id for the '<em><b>Left Header Column</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN = 2;
+
+	/**
+	 * The number of structural features of the '<em>Pror Spec View Configuration</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_SPEC_VIEW_CONFIGURATION_FEATURE_COUNT = 3;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl <em>Column</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getColumn()
+	 * @generated
+	 */
+	int COLUMN = 2;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COLUMN__LABEL = 0;
+
+	/**
+	 * The feature id for the '<em><b>Width</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COLUMN__WIDTH = 1;
+
+	/**
+	 * The number of structural features of the '<em>Column</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COLUMN_FEATURE_COUNT = 2;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl <em>Pror Presentation Configurations</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfigurations()
+	 * @generated
+	 */
+	int PROR_PRESENTATION_CONFIGURATIONS = 3;
+
+	/**
+	 * The feature id for the '<em><b>Presentation Configurations</b></em>' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS = 0;
+
+	/**
+	 * The number of structural features of the '<em>Pror Presentation Configurations</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_PRESENTATION_CONFIGURATIONS_FEATURE_COUNT = 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl <em>Pror Presentation Configuration</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfiguration()
+	 * @generated
+	 */
+	int PROR_PRESENTATION_CONFIGURATION = 4;
+
+	/**
+	 * The feature id for the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_PRESENTATION_CONFIGURATION__DATATYPE = 0;
+
+	/**
+	 * The number of structural features of the '<em>Pror Presentation Configuration</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_PRESENTATION_CONFIGURATION_FEATURE_COUNT = 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl <em>Pror General Configuration</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrGeneralConfiguration()
+	 * @generated
+	 */
+	int PROR_GENERAL_CONFIGURATION = 5;
+
+	/**
+	 * The feature id for the '<em><b>Label Configuration</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION = 0;
+
+	/**
+	 * The number of structural features of the '<em>Pror General Configuration</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int PROR_GENERAL_CONFIGURATION_FEATURE_COUNT = 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl <em>Label Configuration</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getLabelConfiguration()
+	 * @generated
+	 */
+	int LABEL_CONFIGURATION = 6;
+
+	/**
+	 * The feature id for the '<em><b>Default Label</b></em>' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LABEL_CONFIGURATION__DEFAULT_LABEL = 0;
+
+	/**
+	 * The number of structural features of the '<em>Label Configuration</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int LABEL_CONFIGURATION_FEATURE_COUNT = 1;
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl <em>Unified Column</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getUnifiedColumn()
+	 * @generated
+	 */
+	int UNIFIED_COLUMN = 7;
+
+	/**
+	 * The feature id for the '<em><b>Label</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int UNIFIED_COLUMN__LABEL = COLUMN__LABEL;
+
+	/**
+	 * The feature id for the '<em><b>Width</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int UNIFIED_COLUMN__WIDTH = COLUMN__WIDTH;
+
+	/**
+	 * The number of structural features of the '<em>Unified Column</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int UNIFIED_COLUMN_FEATURE_COUNT = COLUMN_FEATURE_COUNT + 0;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension <em>Pror Tool Extension</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Pror Tool Extension</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension
+	 * @generated
+	 */
+	EClass getProrToolExtension();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Spec View Configurations</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations()
+	 * @see #getProrToolExtension()
+	 * @generated
+	 */
+	EReference getProrToolExtension_SpecViewConfigurations();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>General Configuration</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration()
+	 * @see #getProrToolExtension()
+	 * @generated
+	 */
+	EReference getProrToolExtension_GeneralConfiguration();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Presentation Configurations</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations()
+	 * @see #getProrToolExtension()
+	 * @generated
+	 */
+	EReference getProrToolExtension_PresentationConfigurations();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration <em>Pror Spec View Configuration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Pror Spec View Configuration</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration
+	 * @generated
+	 */
+	EClass getProrSpecViewConfiguration();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Specification</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification()
+	 * @see #getProrSpecViewConfiguration()
+	 * @generated
+	 */
+	EReference getProrSpecViewConfiguration_Specification();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Columns</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns()
+	 * @see #getProrSpecViewConfiguration()
+	 * @generated
+	 */
+	EReference getProrSpecViewConfiguration_Columns();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Left Header Column</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn()
+	 * @see #getProrSpecViewConfiguration()
+	 * @generated
+	 */
+	EReference getProrSpecViewConfiguration_LeftHeaderColumn();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.Column <em>Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Column</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.Column
+	 * @generated
+	 */
+	EClass getColumn();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel <em>Label</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Label</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.Column#getLabel()
+	 * @see #getColumn()
+	 * @generated
+	 */
+	EAttribute getColumn_Label();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth <em>Width</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Width</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.Column#getWidth()
+	 * @see #getColumn()
+	 * @generated
+	 */
+	EAttribute getColumn_Width();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations <em>Pror Presentation Configurations</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Pror Presentation Configurations</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations
+	 * @generated
+	 */
+	EClass getProrPresentationConfigurations();
+
+	/**
+	 * Returns the meta object for the containment reference list '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference list '<em>Presentation Configurations</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations()
+	 * @see #getProrPresentationConfigurations()
+	 * @generated
+	 */
+	EReference getProrPresentationConfigurations_PresentationConfigurations();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration <em>Pror Presentation Configuration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Pror Presentation Configuration</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration
+	 * @generated
+	 */
+	EClass getProrPresentationConfiguration();
+
+	/**
+	 * Returns the meta object for the reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the reference '<em>Datatype</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype()
+	 * @see #getProrPresentationConfiguration()
+	 * @generated
+	 */
+	EReference getProrPresentationConfiguration_Datatype();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration <em>Pror General Configuration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Pror General Configuration</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration
+	 * @generated
+	 */
+	EClass getProrGeneralConfiguration();
+
+	/**
+	 * Returns the meta object for the containment reference '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the containment reference '<em>Label Configuration</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration()
+	 * @see #getProrGeneralConfiguration()
+	 * @generated
+	 */
+	EReference getProrGeneralConfiguration_LabelConfiguration();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration <em>Label Configuration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Label Configuration</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration
+	 * @generated
+	 */
+	EClass getLabelConfiguration();
+
+	/**
+	 * Returns the meta object for the attribute list '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute list '<em>Default Label</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel()
+	 * @see #getLabelConfiguration()
+	 * @generated
+	 */
+	EAttribute getLabelConfiguration_DefaultLabel();
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn <em>Unified Column</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>Unified Column</em>'.
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn
+	 * @generated
+	 */
+	EClass getUnifiedColumn();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	ConfigurationFactory getConfigurationFactory();
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * Defines literals for the meta objects that represent
+	 * <ul>
+	 *   <li>each class,</li>
+	 *   <li>each feature of each class,</li>
+	 *   <li>each enum,</li>
+	 *   <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl <em>Pror Tool Extension</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrToolExtension()
+		 * @generated
+		 */
+		EClass PROR_TOOL_EXTENSION = eINSTANCE.getProrToolExtension();
+
+		/**
+		 * The meta object literal for the '<em><b>Spec View Configurations</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS = eINSTANCE.getProrToolExtension_SpecViewConfigurations();
+
+		/**
+		 * The meta object literal for the '<em><b>General Configuration</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION = eINSTANCE.getProrToolExtension_GeneralConfiguration();
+
+		/**
+		 * The meta object literal for the '<em><b>Presentation Configurations</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS = eINSTANCE.getProrToolExtension_PresentationConfigurations();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl <em>Pror Spec View Configuration</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrSpecViewConfiguration()
+		 * @generated
+		 */
+		EClass PROR_SPEC_VIEW_CONFIGURATION = eINSTANCE.getProrSpecViewConfiguration();
+
+		/**
+		 * The meta object literal for the '<em><b>Specification</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION = eINSTANCE.getProrSpecViewConfiguration_Specification();
+
+		/**
+		 * The meta object literal for the '<em><b>Columns</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_SPEC_VIEW_CONFIGURATION__COLUMNS = eINSTANCE.getProrSpecViewConfiguration_Columns();
+
+		/**
+		 * The meta object literal for the '<em><b>Left Header Column</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN = eINSTANCE.getProrSpecViewConfiguration_LeftHeaderColumn();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl <em>Column</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getColumn()
+		 * @generated
+		 */
+		EClass COLUMN = eINSTANCE.getColumn();
+
+		/**
+		 * The meta object literal for the '<em><b>Label</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute COLUMN__LABEL = eINSTANCE.getColumn_Label();
+
+		/**
+		 * The meta object literal for the '<em><b>Width</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute COLUMN__WIDTH = eINSTANCE.getColumn_Width();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl <em>Pror Presentation Configurations</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfigurations()
+		 * @generated
+		 */
+		EClass PROR_PRESENTATION_CONFIGURATIONS = eINSTANCE.getProrPresentationConfigurations();
+
+		/**
+		 * The meta object literal for the '<em><b>Presentation Configurations</b></em>' containment reference list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS = eINSTANCE.getProrPresentationConfigurations_PresentationConfigurations();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl <em>Pror Presentation Configuration</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrPresentationConfiguration()
+		 * @generated
+		 */
+		EClass PROR_PRESENTATION_CONFIGURATION = eINSTANCE.getProrPresentationConfiguration();
+
+		/**
+		 * The meta object literal for the '<em><b>Datatype</b></em>' reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_PRESENTATION_CONFIGURATION__DATATYPE = eINSTANCE.getProrPresentationConfiguration_Datatype();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl <em>Pror General Configuration</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getProrGeneralConfiguration()
+		 * @generated
+		 */
+		EClass PROR_GENERAL_CONFIGURATION = eINSTANCE.getProrGeneralConfiguration();
+
+		/**
+		 * The meta object literal for the '<em><b>Label Configuration</b></em>' containment reference feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EReference PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION = eINSTANCE.getProrGeneralConfiguration_LabelConfiguration();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl <em>Label Configuration</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getLabelConfiguration()
+		 * @generated
+		 */
+		EClass LABEL_CONFIGURATION = eINSTANCE.getLabelConfiguration();
+
+		/**
+		 * The meta object literal for the '<em><b>Default Label</b></em>' attribute list feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute LABEL_CONFIGURATION__DEFAULT_LABEL = eINSTANCE.getLabelConfiguration_DefaultLabel();
+
+		/**
+		 * The meta object literal for the '{@link org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl <em>Unified Column</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.UnifiedColumnImpl
+		 * @see org.eclipse.rmf.reqif10.pror.configuration.impl.ConfigurationPackageImpl#getUnifiedColumn()
+		 * @generated
+		 */
+		EClass UNIFIED_COLUMN = eINSTANCE.getUnifiedColumn();
+
+	}
+
+} //ConfigurationPackage
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/LabelConfiguration.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/LabelConfiguration.java
index 8aaf38f..f641334 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/LabelConfiguration.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/LabelConfiguration.java
@@ -1,73 +1,65 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Label Configuration</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getLabelConfiguration()
- * @model
- * @generated
- */
-public interface LabelConfiguration extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Default Label</b></em>' attribute list.
-	 * The list contents are of type {@link java.lang.String}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Default Label</em>' attribute list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Default Label</em>' attribute list.
-	 * @see #isSetDefaultLabel()
-	 * @see #unsetDefaultLabel()
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getLabelConfiguration_DefaultLabel()
-	 * @model unsettable="true"
-	 * @generated
-	 */
-	EList<String> getDefaultLabel();
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetDefaultLabel()
-	 * @see #getDefaultLabel()
-	 * @generated
-	 */
-	void unsetDefaultLabel();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}' attribute list is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Default Label</em>' attribute list is set.
-	 * @see #unsetDefaultLabel()
-	 * @see #getDefaultLabel()
-	 * @generated
-	 */
-	boolean isSetDefaultLabel();
-
-} // LabelConfiguration
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Label Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getLabelConfiguration()
+ * @model
+ * @generated
+ */
+public interface LabelConfiguration extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Default Label</b></em>' attribute list.
+	 * The list contents are of type {@link java.lang.String}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Default Label</em>' attribute list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Default Label</em>' attribute list.
+	 * @see #isSetDefaultLabel()
+	 * @see #unsetDefaultLabel()
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getLabelConfiguration_DefaultLabel()
+	 * @model unsettable="true"
+	 * @generated
+	 */
+	EList<String> getDefaultLabel();
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetDefaultLabel()
+	 * @see #getDefaultLabel()
+	 * @generated
+	 */
+	void unsetDefaultLabel();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration#getDefaultLabel <em>Default Label</em>}' attribute list is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Default Label</em>' attribute list is set.
+	 * @see #unsetDefaultLabel()
+	 * @see #getDefaultLabel()
+	 * @generated
+	 */
+	boolean isSetDefaultLabel();
+
+} // LabelConfiguration
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrGeneralConfiguration.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrGeneralConfiguration.java
index a9e964b..61659be 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrGeneralConfiguration.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrGeneralConfiguration.java
@@ -1,88 +1,79 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pror General Configuration</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrGeneralConfiguration()
- * @model
- * @generated
- */
-public interface ProrGeneralConfiguration extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Label Configuration</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Label Configuration</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Label Configuration</em>' containment reference.
-	 * @see #isSetLabelConfiguration()
-	 * @see #unsetLabelConfiguration()
-	 * @see #setLabelConfiguration(LabelConfiguration)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrGeneralConfiguration_LabelConfiguration()
-	 * @model containment="true" unsettable="true" required="true"
-	 *        extendedMetaData="name='labelConfiguration' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='labelConfiguration' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	LabelConfiguration getLabelConfiguration();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Label Configuration</em>' containment reference.
-	 * @see #isSetLabelConfiguration()
-	 * @see #unsetLabelConfiguration()
-	 * @see #getLabelConfiguration()
-	 * @generated
-	 */
-	void setLabelConfiguration(LabelConfiguration value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetLabelConfiguration()
-	 * @see #getLabelConfiguration()
-	 * @see #setLabelConfiguration(LabelConfiguration)
-	 * @generated
-	 */
-	void unsetLabelConfiguration();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}' containment reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Label Configuration</em>' containment reference is set.
-	 * @see #unsetLabelConfiguration()
-	 * @see #getLabelConfiguration()
-	 * @see #setLabelConfiguration(LabelConfiguration)
-	 * @generated
-	 */
-	boolean isSetLabelConfiguration();
-
-} // ProrGeneralConfiguration
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Pror General Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrGeneralConfiguration()
+ * @model
+ * @generated
+ */
+public interface ProrGeneralConfiguration extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Label Configuration</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Label Configuration</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Label Configuration</em>' containment reference.
+	 * @see #isSetLabelConfiguration()
+	 * @see #unsetLabelConfiguration()
+	 * @see #setLabelConfiguration(LabelConfiguration)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrGeneralConfiguration_LabelConfiguration()
+	 * @model containment="true" unsettable="true" required="true"
+	 *        extendedMetaData="name='labelConfiguration' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='labelConfiguration' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	LabelConfiguration getLabelConfiguration();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Label Configuration</em>' containment reference.
+	 * @see #isSetLabelConfiguration()
+	 * @see #unsetLabelConfiguration()
+	 * @see #getLabelConfiguration()
+	 * @generated
+	 */
+	void setLabelConfiguration(LabelConfiguration value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetLabelConfiguration()
+	 * @see #getLabelConfiguration()
+	 * @see #setLabelConfiguration(LabelConfiguration)
+	 * @generated
+	 */
+	void unsetLabelConfiguration();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration#getLabelConfiguration <em>Label Configuration</em>}' containment reference is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Label Configuration</em>' containment reference is set.
+	 * @see #unsetLabelConfiguration()
+	 * @see #getLabelConfiguration()
+	 * @see #setLabelConfiguration(LabelConfiguration)
+	 * @generated
+	 */
+	boolean isSetLabelConfiguration();
+
+} // ProrGeneralConfiguration
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfiguration.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfiguration.java
index 827e1d8..6c53708 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfiguration.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfiguration.java
@@ -1,87 +1,79 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.rmf.reqif10.DatatypeDefinition;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pror Presentation Configuration</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfiguration()
- * @model abstract="true"
- * @generated
- */
-public interface ProrPresentationConfiguration extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Datatype</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Datatype</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Datatype</em>' reference.
-	 * @see #isSetDatatype()
-	 * @see #unsetDatatype()
-	 * @see #setDatatype(DatatypeDefinition)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfiguration_Datatype()
-	 * @model unsettable="true" required="true"
-	 * @generated
-	 */
-	DatatypeDefinition getDatatype();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Datatype</em>' reference.
-	 * @see #isSetDatatype()
-	 * @see #unsetDatatype()
-	 * @see #getDatatype()
-	 * @generated
-	 */
-	void setDatatype(DatatypeDefinition value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetDatatype()
-	 * @see #getDatatype()
-	 * @see #setDatatype(DatatypeDefinition)
-	 * @generated
-	 */
-	void unsetDatatype();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Datatype</em>' reference is set.
-	 * @see #unsetDatatype()
-	 * @see #getDatatype()
-	 * @see #setDatatype(DatatypeDefinition)
-	 * @generated
-	 */
-	boolean isSetDatatype();
-
-} // ProrPresentationConfiguration
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.rmf.reqif10.DatatypeDefinition;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Pror Presentation Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfiguration()
+ * @model abstract="true"
+ * @generated
+ */
+public interface ProrPresentationConfiguration extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Datatype</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Datatype</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Datatype</em>' reference.
+	 * @see #isSetDatatype()
+	 * @see #unsetDatatype()
+	 * @see #setDatatype(DatatypeDefinition)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfiguration_Datatype()
+	 * @model unsettable="true" required="true"
+	 * @generated
+	 */
+	DatatypeDefinition getDatatype();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Datatype</em>' reference.
+	 * @see #isSetDatatype()
+	 * @see #unsetDatatype()
+	 * @see #getDatatype()
+	 * @generated
+	 */
+	void setDatatype(DatatypeDefinition value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetDatatype()
+	 * @see #getDatatype()
+	 * @see #setDatatype(DatatypeDefinition)
+	 * @generated
+	 */
+	void unsetDatatype();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration#getDatatype <em>Datatype</em>}' reference is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Datatype</em>' reference is set.
+	 * @see #unsetDatatype()
+	 * @see #getDatatype()
+	 * @see #setDatatype(DatatypeDefinition)
+	 * @generated
+	 */
+	boolean isSetDatatype();
+
+} // ProrPresentationConfiguration
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfigurations.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfigurations.java
index ebfe44e..d2633f1 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfigurations.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrPresentationConfigurations.java
@@ -1,75 +1,67 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pror Presentation Configurations</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfigurations()
- * @model
- * @generated
- */
-public interface ProrPresentationConfigurations extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Presentation Configurations</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Presentation Configurations</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Presentation Configurations</em>' containment reference list.
-	 * @see #isSetPresentationConfigurations()
-	 * @see #unsetPresentationConfigurations()
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfigurations_PresentationConfigurations()
-	 * @model containment="true" unsettable="true"
-	 *        extendedMetaData="name='presentationConfigurations' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='presentationConfigurations' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	EList<ProrPresentationConfiguration> getPresentationConfigurations();
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetPresentationConfigurations()
-	 * @see #getPresentationConfigurations()
-	 * @generated
-	 */
-	void unsetPresentationConfigurations();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference list is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Presentation Configurations</em>' containment reference list is set.
-	 * @see #unsetPresentationConfigurations()
-	 * @see #getPresentationConfigurations()
-	 * @generated
-	 */
-	boolean isSetPresentationConfigurations();
-
-} // ProrPresentationConfigurations
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Pror Presentation Configurations</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfigurations()
+ * @model
+ * @generated
+ */
+public interface ProrPresentationConfigurations extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Presentation Configurations</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Presentation Configurations</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Presentation Configurations</em>' containment reference list.
+	 * @see #isSetPresentationConfigurations()
+	 * @see #unsetPresentationConfigurations()
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrPresentationConfigurations_PresentationConfigurations()
+	 * @model containment="true" unsettable="true"
+	 *        extendedMetaData="name='presentationConfigurations' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='presentationConfigurations' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	EList<ProrPresentationConfiguration> getPresentationConfigurations();
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetPresentationConfigurations()
+	 * @see #getPresentationConfigurations()
+	 * @generated
+	 */
+	void unsetPresentationConfigurations();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference list is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Presentation Configurations</em>' containment reference list is set.
+	 * @see #unsetPresentationConfigurations()
+	 * @see #getPresentationConfigurations()
+	 * @generated
+	 */
+	boolean isSetPresentationConfigurations();
+
+} // ProrPresentationConfigurations
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrSpecViewConfiguration.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrSpecViewConfiguration.java
index 8a29546..57dca79 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrSpecViewConfiguration.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrSpecViewConfiguration.java
@@ -1,186 +1,179 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.rmf.reqif10.Specification;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pror Spec View Configuration</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration()
- * @model
- * @generated
- */
-public interface ProrSpecViewConfiguration extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Specification</b></em>' reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Specification</em>' reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Specification</em>' reference.
-	 * @see #isSetSpecification()
-	 * @see #unsetSpecification()
-	 * @see #setSpecification(Specification)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration_Specification()
-	 * @model unsettable="true" required="true"
-	 * @generated
-	 */
-	Specification getSpecification();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Specification</em>' reference.
-	 * @see #isSetSpecification()
-	 * @see #unsetSpecification()
-	 * @see #getSpecification()
-	 * @generated
-	 */
-	void setSpecification(Specification value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetSpecification()
-	 * @see #getSpecification()
-	 * @see #setSpecification(Specification)
-	 * @generated
-	 */
-	void unsetSpecification();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}' reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Specification</em>' reference is set.
-	 * @see #unsetSpecification()
-	 * @see #getSpecification()
-	 * @see #setSpecification(Specification)
-	 * @generated
-	 */
-	boolean isSetSpecification();
-
-	/**
-	 * Returns the value of the '<em><b>Columns</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.rmf.reqif10.pror.configuration.Column}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Columns</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Columns</em>' containment reference list.
-	 * @see #isSetColumns()
-	 * @see #unsetColumns()
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration_Columns()
-	 * @model containment="true" unsettable="true"
-	 *        extendedMetaData="name='columns' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='columns' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	EList<Column> getColumns();
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetColumns()
-	 * @see #getColumns()
-	 * @generated
-	 */
-	void unsetColumns();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}' containment reference list is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Columns</em>' containment reference list is set.
-	 * @see #unsetColumns()
-	 * @see #getColumns()
-	 * @generated
-	 */
-	boolean isSetColumns();
-
-	/**
-	 * Returns the value of the '<em><b>Left Header Column</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Left Header Column</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Left Header Column</em>' containment reference.
-	 * @see #isSetLeftHeaderColumn()
-	 * @see #unsetLeftHeaderColumn()
-	 * @see #setLeftHeaderColumn(Column)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration_LeftHeaderColumn()
-	 * @model containment="true" unsettable="true" required="true"
-	 *        extendedMetaData="name='leftHeaderColumn' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='leftHeaderColumn' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	Column getLeftHeaderColumn();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Left Header Column</em>' containment reference.
-	 * @see #isSetLeftHeaderColumn()
-	 * @see #unsetLeftHeaderColumn()
-	 * @see #getLeftHeaderColumn()
-	 * @generated
-	 */
-	void setLeftHeaderColumn(Column value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetLeftHeaderColumn()
-	 * @see #getLeftHeaderColumn()
-	 * @see #setLeftHeaderColumn(Column)
-	 * @generated
-	 */
-	void unsetLeftHeaderColumn();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}' containment reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Left Header Column</em>' containment reference is set.
-	 * @see #unsetLeftHeaderColumn()
-	 * @see #getLeftHeaderColumn()
-	 * @see #setLeftHeaderColumn(Column)
-	 * @generated
-	 */
-	boolean isSetLeftHeaderColumn();
-
-} // ProrSpecViewConfiguration
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.rmf.reqif10.Specification;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Pror Spec View Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration()
+ * @model
+ * @generated
+ */
+public interface ProrSpecViewConfiguration extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Specification</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Specification</em>' reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Specification</em>' reference.
+	 * @see #isSetSpecification()
+	 * @see #unsetSpecification()
+	 * @see #setSpecification(Specification)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration_Specification()
+	 * @model unsettable="true" required="true"
+	 * @generated
+	 */
+	Specification getSpecification();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Specification</em>' reference.
+	 * @see #isSetSpecification()
+	 * @see #unsetSpecification()
+	 * @see #getSpecification()
+	 * @generated
+	 */
+	void setSpecification(Specification value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetSpecification()
+	 * @see #getSpecification()
+	 * @see #setSpecification(Specification)
+	 * @generated
+	 */
+	void unsetSpecification();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getSpecification <em>Specification</em>}' reference is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Specification</em>' reference is set.
+	 * @see #unsetSpecification()
+	 * @see #getSpecification()
+	 * @see #setSpecification(Specification)
+	 * @generated
+	 */
+	boolean isSetSpecification();
+
+	/**
+	 * Returns the value of the '<em><b>Columns</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.rmf.reqif10.pror.configuration.Column}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Columns</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Columns</em>' containment reference list.
+	 * @see #isSetColumns()
+	 * @see #unsetColumns()
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration_Columns()
+	 * @model containment="true" unsettable="true"
+	 *        extendedMetaData="name='columns' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='columns' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	EList<Column> getColumns();
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetColumns()
+	 * @see #getColumns()
+	 * @generated
+	 */
+	void unsetColumns();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getColumns <em>Columns</em>}' containment reference list is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Columns</em>' containment reference list is set.
+	 * @see #unsetColumns()
+	 * @see #getColumns()
+	 * @generated
+	 */
+	boolean isSetColumns();
+
+	/**
+	 * Returns the value of the '<em><b>Left Header Column</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Left Header Column</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Left Header Column</em>' containment reference.
+	 * @see #isSetLeftHeaderColumn()
+	 * @see #unsetLeftHeaderColumn()
+	 * @see #setLeftHeaderColumn(Column)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrSpecViewConfiguration_LeftHeaderColumn()
+	 * @model containment="true" unsettable="true" required="true"
+	 *        extendedMetaData="name='leftHeaderColumn' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='leftHeaderColumn' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	Column getLeftHeaderColumn();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Left Header Column</em>' containment reference.
+	 * @see #isSetLeftHeaderColumn()
+	 * @see #unsetLeftHeaderColumn()
+	 * @see #getLeftHeaderColumn()
+	 * @generated
+	 */
+	void setLeftHeaderColumn(Column value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetLeftHeaderColumn()
+	 * @see #getLeftHeaderColumn()
+	 * @see #setLeftHeaderColumn(Column)
+	 * @generated
+	 */
+	void unsetLeftHeaderColumn();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration#getLeftHeaderColumn <em>Left Header Column</em>}' containment reference is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Left Header Column</em>' containment reference is set.
+	 * @see #unsetLeftHeaderColumn()
+	 * @see #getLeftHeaderColumn()
+	 * @see #setLeftHeaderColumn(Column)
+	 * @generated
+	 */
+	boolean isSetLeftHeaderColumn();
+
+} // ProrSpecViewConfiguration
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrToolExtension.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrToolExtension.java
index 294283c..b2e98aa 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrToolExtension.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/ProrToolExtension.java
@@ -1,187 +1,179 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EObject;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pror Tool Extension</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension()
- * @model
- * @generated
- */
-public interface ProrToolExtension extends EObject {
-	/**
-	 * Returns the value of the '<em><b>Spec View Configurations</b></em>' containment reference list.
-	 * The list contents are of type {@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration}.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Spec View Configurations</em>' containment reference list isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Spec View Configurations</em>' containment reference list.
-	 * @see #isSetSpecViewConfigurations()
-	 * @see #unsetSpecViewConfigurations()
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension_SpecViewConfigurations()
-	 * @model containment="true" unsettable="true"
-	 *        extendedMetaData="name='specViewConfigurations' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='specViewConfigurations' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	EList<ProrSpecViewConfiguration> getSpecViewConfigurations();
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetSpecViewConfigurations()
-	 * @see #getSpecViewConfigurations()
-	 * @generated
-	 */
-	void unsetSpecViewConfigurations();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}' containment reference list is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Spec View Configurations</em>' containment reference list is set.
-	 * @see #unsetSpecViewConfigurations()
-	 * @see #getSpecViewConfigurations()
-	 * @generated
-	 */
-	boolean isSetSpecViewConfigurations();
-
-	/**
-	 * Returns the value of the '<em><b>General Configuration</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>General Configuration</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>General Configuration</em>' containment reference.
-	 * @see #isSetGeneralConfiguration()
-	 * @see #unsetGeneralConfiguration()
-	 * @see #setGeneralConfiguration(ProrGeneralConfiguration)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension_GeneralConfiguration()
-	 * @model containment="true" unsettable="true" required="true"
-	 *        extendedMetaData="name='generalConfiguration' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='generalConfiguration' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	ProrGeneralConfiguration getGeneralConfiguration();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>General Configuration</em>' containment reference.
-	 * @see #isSetGeneralConfiguration()
-	 * @see #unsetGeneralConfiguration()
-	 * @see #getGeneralConfiguration()
-	 * @generated
-	 */
-	void setGeneralConfiguration(ProrGeneralConfiguration value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetGeneralConfiguration()
-	 * @see #getGeneralConfiguration()
-	 * @see #setGeneralConfiguration(ProrGeneralConfiguration)
-	 * @generated
-	 */
-	void unsetGeneralConfiguration();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}' containment reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>General Configuration</em>' containment reference is set.
-	 * @see #unsetGeneralConfiguration()
-	 * @see #getGeneralConfiguration()
-	 * @see #setGeneralConfiguration(ProrGeneralConfiguration)
-	 * @generated
-	 */
-	boolean isSetGeneralConfiguration();
-
-	/**
-	 * Returns the value of the '<em><b>Presentation Configurations</b></em>' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <p>
-	 * If the meaning of the '<em>Presentation Configurations</em>' containment reference isn't clear,
-	 * there really should be more of a description here...
-	 * </p>
-	 * <!-- end-user-doc -->
-	 * @return the value of the '<em>Presentation Configurations</em>' containment reference.
-	 * @see #isSetPresentationConfigurations()
-	 * @see #unsetPresentationConfigurations()
-	 * @see #setPresentationConfigurations(ProrPresentationConfigurations)
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension_PresentationConfigurations()
-	 * @model containment="true" unsettable="true" required="true"
-	 *        extendedMetaData="name='presentationConfigurations' kind='element' namespace='##targetNamespace'"
-	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='presentationConfigurations' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
-	 * @generated
-	 */
-	ProrPresentationConfigurations getPresentationConfigurations();
-
-	/**
-	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param value the new value of the '<em>Presentation Configurations</em>' containment reference.
-	 * @see #isSetPresentationConfigurations()
-	 * @see #unsetPresentationConfigurations()
-	 * @see #getPresentationConfigurations()
-	 * @generated
-	 */
-	void setPresentationConfigurations(ProrPresentationConfigurations value);
-
-	/**
-	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #isSetPresentationConfigurations()
-	 * @see #getPresentationConfigurations()
-	 * @see #setPresentationConfigurations(ProrPresentationConfigurations)
-	 * @generated
-	 */
-	void unsetPresentationConfigurations();
-
-	/**
-	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference is set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @return whether the value of the '<em>Presentation Configurations</em>' containment reference is set.
-	 * @see #unsetPresentationConfigurations()
-	 * @see #getPresentationConfigurations()
-	 * @see #setPresentationConfigurations(ProrPresentationConfigurations)
-	 * @generated
-	 */
-	boolean isSetPresentationConfigurations();
-
-} // ProrToolExtension
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Pror Tool Extension</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension()
+ * @model
+ * @generated
+ */
+public interface ProrToolExtension extends EObject {
+	/**
+	 * Returns the value of the '<em><b>Spec View Configurations</b></em>' containment reference list.
+	 * The list contents are of type {@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration}.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Spec View Configurations</em>' containment reference list isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Spec View Configurations</em>' containment reference list.
+	 * @see #isSetSpecViewConfigurations()
+	 * @see #unsetSpecViewConfigurations()
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension_SpecViewConfigurations()
+	 * @model containment="true" unsettable="true"
+	 *        extendedMetaData="name='specViewConfigurations' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='specViewConfigurations' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	EList<ProrSpecViewConfiguration> getSpecViewConfigurations();
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetSpecViewConfigurations()
+	 * @see #getSpecViewConfigurations()
+	 * @generated
+	 */
+	void unsetSpecViewConfigurations();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getSpecViewConfigurations <em>Spec View Configurations</em>}' containment reference list is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Spec View Configurations</em>' containment reference list is set.
+	 * @see #unsetSpecViewConfigurations()
+	 * @see #getSpecViewConfigurations()
+	 * @generated
+	 */
+	boolean isSetSpecViewConfigurations();
+
+	/**
+	 * Returns the value of the '<em><b>General Configuration</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>General Configuration</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>General Configuration</em>' containment reference.
+	 * @see #isSetGeneralConfiguration()
+	 * @see #unsetGeneralConfiguration()
+	 * @see #setGeneralConfiguration(ProrGeneralConfiguration)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension_GeneralConfiguration()
+	 * @model containment="true" unsettable="true" required="true"
+	 *        extendedMetaData="name='generalConfiguration' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='generalConfiguration' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	ProrGeneralConfiguration getGeneralConfiguration();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>General Configuration</em>' containment reference.
+	 * @see #isSetGeneralConfiguration()
+	 * @see #unsetGeneralConfiguration()
+	 * @see #getGeneralConfiguration()
+	 * @generated
+	 */
+	void setGeneralConfiguration(ProrGeneralConfiguration value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetGeneralConfiguration()
+	 * @see #getGeneralConfiguration()
+	 * @see #setGeneralConfiguration(ProrGeneralConfiguration)
+	 * @generated
+	 */
+	void unsetGeneralConfiguration();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getGeneralConfiguration <em>General Configuration</em>}' containment reference is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>General Configuration</em>' containment reference is set.
+	 * @see #unsetGeneralConfiguration()
+	 * @see #getGeneralConfiguration()
+	 * @see #setGeneralConfiguration(ProrGeneralConfiguration)
+	 * @generated
+	 */
+	boolean isSetGeneralConfiguration();
+
+	/**
+	 * Returns the value of the '<em><b>Presentation Configurations</b></em>' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Presentation Configurations</em>' containment reference isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Presentation Configurations</em>' containment reference.
+	 * @see #isSetPresentationConfigurations()
+	 * @see #unsetPresentationConfigurations()
+	 * @see #setPresentationConfigurations(ProrPresentationConfigurations)
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#getProrToolExtension_PresentationConfigurations()
+	 * @model containment="true" unsettable="true" required="true"
+	 *        extendedMetaData="name='presentationConfigurations' kind='element' namespace='##targetNamespace'"
+	 *        annotation="http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData wrapperName='presentationConfigurations' featureWrapperElement='true' featureElement='false' classifierWrapperElement='false' classifierElement='true'"
+	 * @generated
+	 */
+	ProrPresentationConfigurations getPresentationConfigurations();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Presentation Configurations</em>' containment reference.
+	 * @see #isSetPresentationConfigurations()
+	 * @see #unsetPresentationConfigurations()
+	 * @see #getPresentationConfigurations()
+	 * @generated
+	 */
+	void setPresentationConfigurations(ProrPresentationConfigurations value);
+
+	/**
+	 * Unsets the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSetPresentationConfigurations()
+	 * @see #getPresentationConfigurations()
+	 * @see #setPresentationConfigurations(ProrPresentationConfigurations)
+	 * @generated
+	 */
+	void unsetPresentationConfigurations();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension#getPresentationConfigurations <em>Presentation Configurations</em>}' containment reference is set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Presentation Configurations</em>' containment reference is set.
+	 * @see #unsetPresentationConfigurations()
+	 * @see #getPresentationConfigurations()
+	 * @see #setPresentationConfigurations(ProrPresentationConfigurations)
+	 * @generated
+	 */
+	boolean isSetPresentationConfigurations();
+
+} // ProrToolExtension
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ColumnImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ColumnImpl.java
index 0299cb5..2452c35 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ColumnImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ColumnImpl.java
@@ -1,291 +1,285 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.rmf.reqif10.pror.configuration.Column;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Column</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl#getLabel <em>Label</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl#getWidth <em>Width</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ColumnImpl extends EObjectImpl implements Column {
-	/**
-	 * The default value of the '{@link #getLabel() <em>Label</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLabel()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final String LABEL_EDEFAULT = "<PLEASE SET LABEL>";
-
-	/**
-	 * The cached value of the '{@link #getLabel() <em>Label</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLabel()
-	 * @generated
-	 * @ordered
-	 */
-	protected String label = LABEL_EDEFAULT;
-
-	/**
-	 * This is true if the Label attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean labelESet;
-
-	/**
-	 * The default value of the '{@link #getWidth() <em>Width</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getWidth()
-	 * @generated
-	 * @ordered
-	 */
-	protected static final int WIDTH_EDEFAULT = 100;
-
-	/**
-	 * The cached value of the '{@link #getWidth() <em>Width</em>}' attribute.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getWidth()
-	 * @generated
-	 * @ordered
-	 */
-	protected int width = WIDTH_EDEFAULT;
-
-	/**
-	 * This is true if the Width attribute has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean widthESet;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ColumnImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.COLUMN;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public String getLabel() {
-		return label;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLabel(String newLabel) {
-		String oldLabel = label;
-		label = newLabel;
-		boolean oldLabelESet = labelESet;
-		labelESet = true;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.COLUMN__LABEL, oldLabel, label, !oldLabelESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetLabel() {
-		String oldLabel = label;
-		boolean oldLabelESet = labelESet;
-		label = LABEL_EDEFAULT;
-		labelESet = false;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.COLUMN__LABEL, oldLabel, LABEL_EDEFAULT, oldLabelESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetLabel() {
-		return labelESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public int getWidth() {
-		return width;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setWidth(int newWidth) {
-		int oldWidth = width;
-		width = newWidth;
-		boolean oldWidthESet = widthESet;
-		widthESet = true;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.COLUMN__WIDTH, oldWidth, width, !oldWidthESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetWidth() {
-		int oldWidth = width;
-		boolean oldWidthESet = widthESet;
-		width = WIDTH_EDEFAULT;
-		widthESet = false;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.COLUMN__WIDTH, oldWidth, WIDTH_EDEFAULT, oldWidthESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetWidth() {
-		return widthESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.COLUMN__LABEL:
-				return getLabel();
-			case ConfigurationPackage.COLUMN__WIDTH:
-				return getWidth();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case ConfigurationPackage.COLUMN__LABEL:
-				setLabel((String)newValue);
-				return;
-			case ConfigurationPackage.COLUMN__WIDTH:
-				setWidth((Integer)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.COLUMN__LABEL:
-				unsetLabel();
-				return;
-			case ConfigurationPackage.COLUMN__WIDTH:
-				unsetWidth();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.COLUMN__LABEL:
-				return isSetLabel();
-			case ConfigurationPackage.COLUMN__WIDTH:
-				return isSetWidth();
-		}
-		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(" (label: ");
-		if (labelESet) result.append(label); else result.append("<unset>");
-		result.append(", width: ");
-		if (widthESet) result.append(width); else result.append("<unset>");
-		result.append(')');
-		return result.toString();
-	}
-
-} //ColumnImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.rmf.reqif10.pror.configuration.Column;
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Column</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl#getLabel <em>Label</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ColumnImpl#getWidth <em>Width</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class ColumnImpl extends EObjectImpl implements Column {
+	/**
+	 * The default value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String LABEL_EDEFAULT = "<PLEASE SET LABEL>";
+
+	/**
+	 * The cached value of the '{@link #getLabel() <em>Label</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected String label = LABEL_EDEFAULT;
+
+	/**
+	 * This is true if the Label attribute has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean labelESet;
+
+	/**
+	 * The default value of the '{@link #getWidth() <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final int WIDTH_EDEFAULT = 100;
+
+	/**
+	 * The cached value of the '{@link #getWidth() <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getWidth()
+	 * @generated
+	 * @ordered
+	 */
+	protected int width = WIDTH_EDEFAULT;
+
+	/**
+	 * This is true if the Width attribute has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean widthESet;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ColumnImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.COLUMN;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getLabel() {
+		return label;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setLabel(String newLabel) {
+		String oldLabel = label;
+		label = newLabel;
+		boolean oldLabelESet = labelESet;
+		labelESet = true;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.COLUMN__LABEL, oldLabel, label, !oldLabelESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetLabel() {
+		String oldLabel = label;
+		boolean oldLabelESet = labelESet;
+		label = LABEL_EDEFAULT;
+		labelESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.COLUMN__LABEL, oldLabel, LABEL_EDEFAULT, oldLabelESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetLabel() {
+		return labelESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public int getWidth() {
+		return width;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setWidth(int newWidth) {
+		int oldWidth = width;
+		width = newWidth;
+		boolean oldWidthESet = widthESet;
+		widthESet = true;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.COLUMN__WIDTH, oldWidth, width, !oldWidthESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetWidth() {
+		int oldWidth = width;
+		boolean oldWidthESet = widthESet;
+		width = WIDTH_EDEFAULT;
+		widthESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.COLUMN__WIDTH, oldWidth, WIDTH_EDEFAULT, oldWidthESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetWidth() {
+		return widthESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.COLUMN__LABEL:
+				return getLabel();
+			case ConfigurationPackage.COLUMN__WIDTH:
+				return getWidth();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case ConfigurationPackage.COLUMN__LABEL:
+				setLabel((String)newValue);
+				return;
+			case ConfigurationPackage.COLUMN__WIDTH:
+				setWidth((Integer)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.COLUMN__LABEL:
+				unsetLabel();
+				return;
+			case ConfigurationPackage.COLUMN__WIDTH:
+				unsetWidth();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.COLUMN__LABEL:
+				return isSetLabel();
+			case ConfigurationPackage.COLUMN__WIDTH:
+				return isSetWidth();
+		}
+		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(" (label: ");
+		if (labelESet) result.append(label); else result.append("<unset>");
+		result.append(", width: ");
+		if (widthESet) result.append(width); else result.append("<unset>");
+		result.append(')');
+		return result.toString();
+	}
+
+} //ColumnImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationFactoryImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationFactoryImpl.java
index 9383ea6..f5251b7 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationFactoryImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationFactoryImpl.java
@@ -1,175 +1,161 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.impl.EFactoryImpl;
-import org.eclipse.emf.ecore.plugin.EcorePlugin;
-import org.eclipse.rmf.reqif10.pror.configuration.*;
-import org.eclipse.rmf.reqif10.pror.configuration.Column;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationFactory;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-public class ConfigurationFactoryImpl extends EFactoryImpl implements ConfigurationFactory {
-	/**
-	 * Creates the default factory implementation.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public static ConfigurationFactory init() {
-		try {
-			ConfigurationFactory theConfigurationFactory = (ConfigurationFactory)EPackage.Registry.INSTANCE.getEFactory(ConfigurationPackage.eNS_URI);
-			if (theConfigurationFactory != null) {
-				return theConfigurationFactory;
-			}
-		}
-		catch (Exception exception) {
-			EcorePlugin.INSTANCE.log(exception);
-		}
-		return new ConfigurationFactoryImpl();
-	}
-
-	/**
-	 * Creates an instance of the factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public EObject create(EClass eClass) {
-		switch (eClass.getClassifierID()) {
-			case ConfigurationPackage.PROR_TOOL_EXTENSION: return createProrToolExtension();
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION: return createProrSpecViewConfiguration();
-			case ConfigurationPackage.COLUMN: return createColumn();
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS: return createProrPresentationConfigurations();
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION: return createProrGeneralConfiguration();
-			case ConfigurationPackage.LABEL_CONFIGURATION: return createLabelConfiguration();
-			case ConfigurationPackage.UNIFIED_COLUMN: return createUnifiedColumn();
-			default:
-				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProrToolExtension createProrToolExtension() {
-		ProrToolExtensionImpl prorToolExtension = new ProrToolExtensionImpl();
-		return prorToolExtension;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProrSpecViewConfiguration createProrSpecViewConfiguration() {
-		ProrSpecViewConfigurationImpl prorSpecViewConfiguration = new ProrSpecViewConfigurationImpl();
-		return prorSpecViewConfiguration;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Column createColumn() {
-		ColumnImpl column = new ColumnImpl();
-		return column;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProrPresentationConfigurations createProrPresentationConfigurations() {
-		ProrPresentationConfigurationsImpl prorPresentationConfigurations = new ProrPresentationConfigurationsImpl();
-		return prorPresentationConfigurations;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProrGeneralConfiguration createProrGeneralConfiguration() {
-		ProrGeneralConfigurationImpl prorGeneralConfiguration = new ProrGeneralConfigurationImpl();
-		return prorGeneralConfiguration;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LabelConfiguration createLabelConfiguration() {
-		LabelConfigurationImpl labelConfiguration = new LabelConfigurationImpl();
-		return labelConfiguration;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public UnifiedColumn createUnifiedColumn() {
-		UnifiedColumnImpl unifiedColumn = new UnifiedColumnImpl();
-		return unifiedColumn;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationPackage getConfigurationPackage() {
-		return (ConfigurationPackage)getEPackage();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @deprecated
-	 * @generated
-	 */
-	@Deprecated
-	public static ConfigurationPackage getPackage() {
-		return ConfigurationPackage.eINSTANCE;
-	}
-
-} //ConfigFactoryImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+import org.eclipse.rmf.reqif10.pror.configuration.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class ConfigurationFactoryImpl extends EFactoryImpl implements ConfigurationFactory {
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static ConfigurationFactory init() {
+		try {
+			ConfigurationFactory theConfigurationFactory = (ConfigurationFactory)EPackage.Registry.INSTANCE.getEFactory(ConfigurationPackage.eNS_URI);
+			if (theConfigurationFactory != null) {
+				return theConfigurationFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new ConfigurationFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ConfigurationFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case ConfigurationPackage.PROR_TOOL_EXTENSION: return createProrToolExtension();
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION: return createProrSpecViewConfiguration();
+			case ConfigurationPackage.COLUMN: return createColumn();
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS: return createProrPresentationConfigurations();
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION: return createProrGeneralConfiguration();
+			case ConfigurationPackage.LABEL_CONFIGURATION: return createLabelConfiguration();
+			case ConfigurationPackage.UNIFIED_COLUMN: return createUnifiedColumn();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ProrToolExtension createProrToolExtension() {
+		ProrToolExtensionImpl prorToolExtension = new ProrToolExtensionImpl();
+		return prorToolExtension;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ProrSpecViewConfiguration createProrSpecViewConfiguration() {
+		ProrSpecViewConfigurationImpl prorSpecViewConfiguration = new ProrSpecViewConfigurationImpl();
+		return prorSpecViewConfiguration;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Column createColumn() {
+		ColumnImpl column = new ColumnImpl();
+		return column;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ProrPresentationConfigurations createProrPresentationConfigurations() {
+		ProrPresentationConfigurationsImpl prorPresentationConfigurations = new ProrPresentationConfigurationsImpl();
+		return prorPresentationConfigurations;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ProrGeneralConfiguration createProrGeneralConfiguration() {
+		ProrGeneralConfigurationImpl prorGeneralConfiguration = new ProrGeneralConfigurationImpl();
+		return prorGeneralConfiguration;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public LabelConfiguration createLabelConfiguration() {
+		LabelConfigurationImpl labelConfiguration = new LabelConfigurationImpl();
+		return labelConfiguration;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public UnifiedColumn createUnifiedColumn() {
+		UnifiedColumnImpl unifiedColumn = new UnifiedColumnImpl();
+		return unifiedColumn;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ConfigurationPackage getConfigurationPackage() {
+		return (ConfigurationPackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static ConfigurationPackage getPackage() {
+		return ConfigurationPackage.eINSTANCE;
+	}
+
+} //ConfigurationFactoryImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationPackageImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationPackageImpl.java
index 5e0ec16..5241e2c 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationPackageImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ConfigurationPackageImpl.java
@@ -1,621 +1,616 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.emf.ecore.xml.namespace.XMLNamespacePackage;
-import org.eclipse.rmf.reqif10.ReqIF10Package;
-import org.eclipse.rmf.reqif10.impl.ReqIF10PackageImpl;
-import org.eclipse.rmf.reqif10.pror.configuration.Column;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationFactory;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
-import org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
- * @generated
- */
-public class ConfigurationPackageImpl extends EPackageImpl implements ConfigurationPackage {
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass prorToolExtensionEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass prorSpecViewConfigurationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass columnEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass prorPresentationConfigurationsEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass prorPresentationConfigurationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass prorGeneralConfigurationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass labelConfigurationEClass = null;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private EClass unifiedColumnEClass = null;
-
-	/**
-	 * Creates an instance of the model <b>Package</b>, registered with
-	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-	 * package URI value.
-	 * <p>Note: the correct way to create the package is via the static
-	 * factory method {@link #init init()}, which also performs
-	 * initialization of the package, or returns the registered package,
-	 * if one already exists.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see org.eclipse.emf.ecore.EPackage.Registry
-	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#eNS_URI
-	 * @see #init()
-	 * @generated
-	 */
-	private ConfigurationPackageImpl() {
-		super(eNS_URI, ConfigurationFactory.eINSTANCE);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private static boolean isInited = false;
-
-	/**
-	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
-	 * 
-	 * <p>This method is used to initialize {@link ConfigurationPackage#eINSTANCE} when that field is accessed.
-	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #eNS_URI
-	 * @see #createPackageContents()
-	 * @see #initializePackageContents()
-	 * @generated
-	 */
-	public static ConfigurationPackage init() {
-		if (isInited) return (ConfigurationPackage)EPackage.Registry.INSTANCE.getEPackage(ConfigurationPackage.eNS_URI);
-
-		// Obtain or create and register package
-		ConfigurationPackageImpl theConfigurationPackage = (ConfigurationPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ConfigurationPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new ConfigurationPackageImpl());
-
-		isInited = true;
-
-		// Initialize simple dependencies
-		XMLNamespacePackage.eINSTANCE.eClass();
-
-		// Obtain or create and register interdependencies
-		ReqIF10PackageImpl theReqIF10Package = (ReqIF10PackageImpl)(EPackage.Registry.INSTANCE.getEPackage(ReqIF10Package.eNS_URI) instanceof ReqIF10PackageImpl ? EPackage.Registry.INSTANCE.getEPackage(ReqIF10Package.eNS_URI) : ReqIF10Package.eINSTANCE);
-
-		// Create package meta-data objects
-		theConfigurationPackage.createPackageContents();
-		theReqIF10Package.createPackageContents();
-
-		// Initialize created meta-data
-		theConfigurationPackage.initializePackageContents();
-		theReqIF10Package.initializePackageContents();
-
-		// Mark meta-data to indicate it can't be changed
-		theConfigurationPackage.freeze();
-
-  
-		// Update the registry and return the package
-		EPackage.Registry.INSTANCE.put(ConfigurationPackage.eNS_URI, theConfigurationPackage);
-		return theConfigurationPackage;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getProrToolExtension() {
-		return prorToolExtensionEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrToolExtension_SpecViewConfigurations() {
-		return (EReference)prorToolExtensionEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrToolExtension_GeneralConfiguration() {
-		return (EReference)prorToolExtensionEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrToolExtension_PresentationConfigurations() {
-		return (EReference)prorToolExtensionEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getProrSpecViewConfiguration() {
-		return prorSpecViewConfigurationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrSpecViewConfiguration_Specification() {
-		return (EReference)prorSpecViewConfigurationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrSpecViewConfiguration_Columns() {
-		return (EReference)prorSpecViewConfigurationEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrSpecViewConfiguration_LeftHeaderColumn() {
-		return (EReference)prorSpecViewConfigurationEClass.getEStructuralFeatures().get(2);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getColumn() {
-		return columnEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getColumn_Label() {
-		return (EAttribute)columnEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getColumn_Width() {
-		return (EAttribute)columnEClass.getEStructuralFeatures().get(1);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getProrPresentationConfigurations() {
-		return prorPresentationConfigurationsEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrPresentationConfigurations_PresentationConfigurations() {
-		return (EReference)prorPresentationConfigurationsEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getProrPresentationConfiguration() {
-		return prorPresentationConfigurationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrPresentationConfiguration_Datatype() {
-		return (EReference)prorPresentationConfigurationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getProrGeneralConfiguration() {
-		return prorGeneralConfigurationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EReference getProrGeneralConfiguration_LabelConfiguration() {
-		return (EReference)prorGeneralConfigurationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getLabelConfiguration() {
-		return labelConfigurationEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EAttribute getLabelConfiguration_DefaultLabel() {
-		return (EAttribute)labelConfigurationEClass.getEStructuralFeatures().get(0);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EClass getUnifiedColumn() {
-		return unifiedColumnEClass;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationFactory getConfigurationFactory() {
-		return (ConfigurationFactory)getEFactoryInstance();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isCreated = false;
-
-	/**
-	 * Creates the meta-model objects for the package.  This method is
-	 * guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void createPackageContents() {
-		if (isCreated) return;
-		isCreated = true;
-
-		// Create classes and their features
-		prorToolExtensionEClass = createEClass(PROR_TOOL_EXTENSION);
-		createEReference(prorToolExtensionEClass, PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS);
-		createEReference(prorToolExtensionEClass, PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION);
-		createEReference(prorToolExtensionEClass, PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS);
-
-		prorSpecViewConfigurationEClass = createEClass(PROR_SPEC_VIEW_CONFIGURATION);
-		createEReference(prorSpecViewConfigurationEClass, PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION);
-		createEReference(prorSpecViewConfigurationEClass, PROR_SPEC_VIEW_CONFIGURATION__COLUMNS);
-		createEReference(prorSpecViewConfigurationEClass, PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN);
-
-		columnEClass = createEClass(COLUMN);
-		createEAttribute(columnEClass, COLUMN__LABEL);
-		createEAttribute(columnEClass, COLUMN__WIDTH);
-
-		prorPresentationConfigurationsEClass = createEClass(PROR_PRESENTATION_CONFIGURATIONS);
-		createEReference(prorPresentationConfigurationsEClass, PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS);
-
-		prorPresentationConfigurationEClass = createEClass(PROR_PRESENTATION_CONFIGURATION);
-		createEReference(prorPresentationConfigurationEClass, PROR_PRESENTATION_CONFIGURATION__DATATYPE);
-
-		prorGeneralConfigurationEClass = createEClass(PROR_GENERAL_CONFIGURATION);
-		createEReference(prorGeneralConfigurationEClass, PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION);
-
-		labelConfigurationEClass = createEClass(LABEL_CONFIGURATION);
-		createEAttribute(labelConfigurationEClass, LABEL_CONFIGURATION__DEFAULT_LABEL);
-
-		unifiedColumnEClass = createEClass(UNIFIED_COLUMN);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	private boolean isInitialized = false;
-
-	/**
-	 * Complete the initialization of the package and its meta-model.  This
-	 * method is guarded to have no affect on any invocation but its first.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void initializePackageContents() {
-		if (isInitialized) return;
-		isInitialized = true;
-
-		// Initialize package
-		setName(eNAME);
-		setNsPrefix(eNS_PREFIX);
-		setNsURI(eNS_URI);
-
-		// Obtain other dependent packages
-		ReqIF10Package theReqIF10Package = (ReqIF10Package)EPackage.Registry.INSTANCE.getEPackage(ReqIF10Package.eNS_URI);
-
-		// Create type parameters
-
-		// Set bounds for type parameters
-
-		// Add supertypes to classes
-		unifiedColumnEClass.getESuperTypes().add(this.getColumn());
-
-		// Initialize classes and features; add operations and parameters
-		initEClass(prorToolExtensionEClass, ProrToolExtension.class, "ProrToolExtension", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getProrToolExtension_SpecViewConfigurations(), this.getProrSpecViewConfiguration(), null, "specViewConfigurations", null, 0, -1, ProrToolExtension.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getProrToolExtension_GeneralConfiguration(), this.getProrGeneralConfiguration(), null, "generalConfiguration", null, 1, 1, ProrToolExtension.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getProrToolExtension_PresentationConfigurations(), this.getProrPresentationConfigurations(), null, "presentationConfigurations", null, 1, 1, ProrToolExtension.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(prorSpecViewConfigurationEClass, ProrSpecViewConfiguration.class, "ProrSpecViewConfiguration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getProrSpecViewConfiguration_Specification(), theReqIF10Package.getSpecification(), null, "specification", null, 1, 1, ProrSpecViewConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getProrSpecViewConfiguration_Columns(), this.getColumn(), null, "columns", null, 0, -1, ProrSpecViewConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEReference(getProrSpecViewConfiguration_LeftHeaderColumn(), this.getColumn(), null, "leftHeaderColumn", null, 1, 1, ProrSpecViewConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(columnEClass, Column.class, "Column", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getColumn_Label(), ecorePackage.getEString(), "label", "<PLEASE SET LABEL>", 1, 1, Column.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-		initEAttribute(getColumn_Width(), ecorePackage.getEInt(), "width", "100", 1, 1, Column.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(prorPresentationConfigurationsEClass, ProrPresentationConfigurations.class, "ProrPresentationConfigurations", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getProrPresentationConfigurations_PresentationConfigurations(), this.getProrPresentationConfiguration(), null, "presentationConfigurations", null, 0, -1, ProrPresentationConfigurations.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(prorPresentationConfigurationEClass, ProrPresentationConfiguration.class, "ProrPresentationConfiguration", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getProrPresentationConfiguration_Datatype(), theReqIF10Package.getDatatypeDefinition(), null, "datatype", null, 1, 1, ProrPresentationConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(prorGeneralConfigurationEClass, ProrGeneralConfiguration.class, "ProrGeneralConfiguration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEReference(getProrGeneralConfiguration_LabelConfiguration(), this.getLabelConfiguration(), null, "labelConfiguration", null, 1, 1, ProrGeneralConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(labelConfigurationEClass, LabelConfiguration.class, "LabelConfiguration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-		initEAttribute(getLabelConfiguration_DefaultLabel(), ecorePackage.getEString(), "defaultLabel", null, 0, -1, LabelConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-		initEClass(unifiedColumnEClass, UnifiedColumn.class, "UnifiedColumn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-
-		// Create resource
-		createResource(eNS_URI);
-
-		// Create annotations
-		// http:///org/eclipse/emf/ecore/util/ExtendedMetaData
-		createExtendedMetaDataAnnotations();
-		// http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData
-		createXMLPersistenceMappingExtendedMetaDataAnnotations();
-	}
-
-	/**
-	 * Initializes the annotations for <b>http:///org/eclipse/emf/ecore/util/ExtendedMetaData</b>.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void createExtendedMetaDataAnnotations() {
-		String source = "http:///org/eclipse/emf/ecore/util/ExtendedMetaData";	
-		addAnnotation
-		  (getProrToolExtension_SpecViewConfigurations(), 
-		   source, 
-		   new String[] {
-			 "name", "specViewConfigurations",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });	
-		addAnnotation
-		  (getProrToolExtension_GeneralConfiguration(), 
-		   source, 
-		   new String[] {
-			 "name", "generalConfiguration",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });	
-		addAnnotation
-		  (getProrToolExtension_PresentationConfigurations(), 
-		   source, 
-		   new String[] {
-			 "name", "presentationConfigurations",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });	
-		addAnnotation
-		  (getProrSpecViewConfiguration_Columns(), 
-		   source, 
-		   new String[] {
-			 "name", "columns",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });	
-		addAnnotation
-		  (getProrSpecViewConfiguration_LeftHeaderColumn(), 
-		   source, 
-		   new String[] {
-			 "name", "leftHeaderColumn",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });	
-		addAnnotation
-		  (getProrPresentationConfigurations_PresentationConfigurations(), 
-		   source, 
-		   new String[] {
-			 "name", "presentationConfigurations",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });	
-		addAnnotation
-		  (getProrGeneralConfiguration_LabelConfiguration(), 
-		   source, 
-		   new String[] {
-			 "name", "labelConfiguration",
-			 "kind", "element",
-			 "namespace", "##targetNamespace"
-		   });
-	}
-
-	/**
-	 * Initializes the annotations for <b>http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData</b>.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected void createXMLPersistenceMappingExtendedMetaDataAnnotations() {
-		String source = "http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData";	
-		addAnnotation
-		  (getProrToolExtension_SpecViewConfigurations(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "specViewConfigurations",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });	
-		addAnnotation
-		  (getProrToolExtension_GeneralConfiguration(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "generalConfiguration",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });	
-		addAnnotation
-		  (getProrToolExtension_PresentationConfigurations(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "presentationConfigurations",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });	
-		addAnnotation
-		  (getProrSpecViewConfiguration_Columns(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "columns",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });	
-		addAnnotation
-		  (getProrSpecViewConfiguration_LeftHeaderColumn(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "leftHeaderColumn",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });	
-		addAnnotation
-		  (getProrPresentationConfigurations_PresentationConfigurations(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "presentationConfigurations",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });	
-		addAnnotation
-		  (getProrGeneralConfiguration_LabelConfiguration(), 
-		   source, 
-		   new String[] {
-			 "wrapperName", "labelConfiguration",
-			 "featureWrapperElement", "true",
-			 "featureElement", "false",
-			 "classifierWrapperElement", "false",
-			 "classifierElement", "true"
-		   });
-	}
-
-} //ConfigPackageImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.emf.ecore.xml.namespace.XMLNamespacePackage;
+
+import org.eclipse.rmf.reqif10.ReqIF10Package;
+
+import org.eclipse.rmf.reqif10.impl.ReqIF10PackageImpl;
+
+import org.eclipse.rmf.reqif10.pror.configuration.Column;
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationFactory;
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
+import org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class ConfigurationPackageImpl extends EPackageImpl implements ConfigurationPackage {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass prorToolExtensionEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass prorSpecViewConfigurationEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass columnEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass prorPresentationConfigurationsEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass prorPresentationConfigurationEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass prorGeneralConfigurationEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass labelConfigurationEClass = null;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass unifiedColumnEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private ConfigurationPackageImpl() {
+		super(eNS_URI, ConfigurationFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+	 * 
+	 * <p>This method is used to initialize {@link ConfigurationPackage#eINSTANCE} when that field is accessed.
+	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static ConfigurationPackage init() {
+		if (isInited) return (ConfigurationPackage)EPackage.Registry.INSTANCE.getEPackage(ConfigurationPackage.eNS_URI);
+
+		// Obtain or create and register package
+		ConfigurationPackageImpl theConfigurationPackage = (ConfigurationPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ConfigurationPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new ConfigurationPackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		XMLNamespacePackage.eINSTANCE.eClass();
+
+		// Obtain or create and register interdependencies
+		ReqIF10PackageImpl theReqIF10Package = (ReqIF10PackageImpl)(EPackage.Registry.INSTANCE.getEPackage(ReqIF10Package.eNS_URI) instanceof ReqIF10PackageImpl ? EPackage.Registry.INSTANCE.getEPackage(ReqIF10Package.eNS_URI) : ReqIF10Package.eINSTANCE);
+
+		// Create package meta-data objects
+		theConfigurationPackage.createPackageContents();
+		theReqIF10Package.createPackageContents();
+
+		// Initialize created meta-data
+		theConfigurationPackage.initializePackageContents();
+		theReqIF10Package.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theConfigurationPackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(ConfigurationPackage.eNS_URI, theConfigurationPackage);
+		return theConfigurationPackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getProrToolExtension() {
+		return prorToolExtensionEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrToolExtension_SpecViewConfigurations() {
+		return (EReference)prorToolExtensionEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrToolExtension_GeneralConfiguration() {
+		return (EReference)prorToolExtensionEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrToolExtension_PresentationConfigurations() {
+		return (EReference)prorToolExtensionEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getProrSpecViewConfiguration() {
+		return prorSpecViewConfigurationEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrSpecViewConfiguration_Specification() {
+		return (EReference)prorSpecViewConfigurationEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrSpecViewConfiguration_Columns() {
+		return (EReference)prorSpecViewConfigurationEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrSpecViewConfiguration_LeftHeaderColumn() {
+		return (EReference)prorSpecViewConfigurationEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getColumn() {
+		return columnEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getColumn_Label() {
+		return (EAttribute)columnEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getColumn_Width() {
+		return (EAttribute)columnEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getProrPresentationConfigurations() {
+		return prorPresentationConfigurationsEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrPresentationConfigurations_PresentationConfigurations() {
+		return (EReference)prorPresentationConfigurationsEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getProrPresentationConfiguration() {
+		return prorPresentationConfigurationEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrPresentationConfiguration_Datatype() {
+		return (EReference)prorPresentationConfigurationEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getProrGeneralConfiguration() {
+		return prorGeneralConfigurationEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EReference getProrGeneralConfiguration_LabelConfiguration() {
+		return (EReference)prorGeneralConfigurationEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getLabelConfiguration() {
+		return labelConfigurationEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getLabelConfiguration_DefaultLabel() {
+		return (EAttribute)labelConfigurationEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getUnifiedColumn() {
+		return unifiedColumnEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ConfigurationFactory getConfigurationFactory() {
+		return (ConfigurationFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		prorToolExtensionEClass = createEClass(PROR_TOOL_EXTENSION);
+		createEReference(prorToolExtensionEClass, PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS);
+		createEReference(prorToolExtensionEClass, PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION);
+		createEReference(prorToolExtensionEClass, PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS);
+
+		prorSpecViewConfigurationEClass = createEClass(PROR_SPEC_VIEW_CONFIGURATION);
+		createEReference(prorSpecViewConfigurationEClass, PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION);
+		createEReference(prorSpecViewConfigurationEClass, PROR_SPEC_VIEW_CONFIGURATION__COLUMNS);
+		createEReference(prorSpecViewConfigurationEClass, PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN);
+
+		columnEClass = createEClass(COLUMN);
+		createEAttribute(columnEClass, COLUMN__LABEL);
+		createEAttribute(columnEClass, COLUMN__WIDTH);
+
+		prorPresentationConfigurationsEClass = createEClass(PROR_PRESENTATION_CONFIGURATIONS);
+		createEReference(prorPresentationConfigurationsEClass, PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS);
+
+		prorPresentationConfigurationEClass = createEClass(PROR_PRESENTATION_CONFIGURATION);
+		createEReference(prorPresentationConfigurationEClass, PROR_PRESENTATION_CONFIGURATION__DATATYPE);
+
+		prorGeneralConfigurationEClass = createEClass(PROR_GENERAL_CONFIGURATION);
+		createEReference(prorGeneralConfigurationEClass, PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION);
+
+		labelConfigurationEClass = createEClass(LABEL_CONFIGURATION);
+		createEAttribute(labelConfigurationEClass, LABEL_CONFIGURATION__DEFAULT_LABEL);
+
+		unifiedColumnEClass = createEClass(UNIFIED_COLUMN);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		ReqIF10Package theReqIF10Package = (ReqIF10Package)EPackage.Registry.INSTANCE.getEPackage(ReqIF10Package.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		unifiedColumnEClass.getESuperTypes().add(this.getColumn());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(prorToolExtensionEClass, ProrToolExtension.class, "ProrToolExtension", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getProrToolExtension_SpecViewConfigurations(), this.getProrSpecViewConfiguration(), null, "specViewConfigurations", null, 0, -1, ProrToolExtension.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getProrToolExtension_GeneralConfiguration(), this.getProrGeneralConfiguration(), null, "generalConfiguration", null, 1, 1, ProrToolExtension.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getProrToolExtension_PresentationConfigurations(), this.getProrPresentationConfigurations(), null, "presentationConfigurations", null, 1, 1, ProrToolExtension.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(prorSpecViewConfigurationEClass, ProrSpecViewConfiguration.class, "ProrSpecViewConfiguration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getProrSpecViewConfiguration_Specification(), theReqIF10Package.getSpecification(), null, "specification", null, 1, 1, ProrSpecViewConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getProrSpecViewConfiguration_Columns(), this.getColumn(), null, "columns", null, 0, -1, ProrSpecViewConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEReference(getProrSpecViewConfiguration_LeftHeaderColumn(), this.getColumn(), null, "leftHeaderColumn", null, 1, 1, ProrSpecViewConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(columnEClass, Column.class, "Column", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getColumn_Label(), ecorePackage.getEString(), "label", "<PLEASE SET LABEL>", 1, 1, Column.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getColumn_Width(), ecorePackage.getEInt(), "width", "100", 1, 1, Column.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(prorPresentationConfigurationsEClass, ProrPresentationConfigurations.class, "ProrPresentationConfigurations", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getProrPresentationConfigurations_PresentationConfigurations(), this.getProrPresentationConfiguration(), null, "presentationConfigurations", null, 0, -1, ProrPresentationConfigurations.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(prorPresentationConfigurationEClass, ProrPresentationConfiguration.class, "ProrPresentationConfiguration", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getProrPresentationConfiguration_Datatype(), theReqIF10Package.getDatatypeDefinition(), null, "datatype", null, 1, 1, ProrPresentationConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(prorGeneralConfigurationEClass, ProrGeneralConfiguration.class, "ProrGeneralConfiguration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEReference(getProrGeneralConfiguration_LabelConfiguration(), this.getLabelConfiguration(), null, "labelConfiguration", null, 1, 1, ProrGeneralConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(labelConfigurationEClass, LabelConfiguration.class, "LabelConfiguration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getLabelConfiguration_DefaultLabel(), ecorePackage.getEString(), "defaultLabel", null, 0, -1, LabelConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		initEClass(unifiedColumnEClass, UnifiedColumn.class, "UnifiedColumn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+		// Create resource
+		createResource(eNS_URI);
+
+		// Create annotations
+		// http:///org/eclipse/emf/ecore/util/ExtendedMetaData
+		createExtendedMetaDataAnnotations();
+		// http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData
+		createXMLPersistenceMappingExtendedMetaDataAnnotations();
+	}
+
+	/**
+	 * Initializes the annotations for <b>http:///org/eclipse/emf/ecore/util/ExtendedMetaData</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void createExtendedMetaDataAnnotations() {
+		String source = "http:///org/eclipse/emf/ecore/util/ExtendedMetaData";	
+		addAnnotation
+		  (getProrToolExtension_SpecViewConfigurations(), 
+		   source, 
+		   new String[] {
+			 "name", "specViewConfigurations",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });	
+		addAnnotation
+		  (getProrToolExtension_GeneralConfiguration(), 
+		   source, 
+		   new String[] {
+			 "name", "generalConfiguration",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });	
+		addAnnotation
+		  (getProrToolExtension_PresentationConfigurations(), 
+		   source, 
+		   new String[] {
+			 "name", "presentationConfigurations",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });	
+		addAnnotation
+		  (getProrSpecViewConfiguration_Columns(), 
+		   source, 
+		   new String[] {
+			 "name", "columns",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });	
+		addAnnotation
+		  (getProrSpecViewConfiguration_LeftHeaderColumn(), 
+		   source, 
+		   new String[] {
+			 "name", "leftHeaderColumn",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });	
+		addAnnotation
+		  (getProrPresentationConfigurations_PresentationConfigurations(), 
+		   source, 
+		   new String[] {
+			 "name", "presentationConfigurations",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });	
+		addAnnotation
+		  (getProrGeneralConfiguration_LabelConfiguration(), 
+		   source, 
+		   new String[] {
+			 "name", "labelConfiguration",
+			 "kind", "element",
+			 "namespace", "##targetNamespace"
+		   });
+	}
+
+	/**
+	 * Initializes the annotations for <b>http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData</b>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void createXMLPersistenceMappingExtendedMetaDataAnnotations() {
+		String source = "http:///org/eclipse/sphinx/emf/serialization/XMLPersistenceMappingExtendedMetaData";	
+		addAnnotation
+		  (getProrToolExtension_SpecViewConfigurations(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "specViewConfigurations",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });	
+		addAnnotation
+		  (getProrToolExtension_GeneralConfiguration(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "generalConfiguration",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });	
+		addAnnotation
+		  (getProrToolExtension_PresentationConfigurations(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "presentationConfigurations",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });	
+		addAnnotation
+		  (getProrSpecViewConfiguration_Columns(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "columns",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });	
+		addAnnotation
+		  (getProrSpecViewConfiguration_LeftHeaderColumn(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "leftHeaderColumn",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });	
+		addAnnotation
+		  (getProrPresentationConfigurations_PresentationConfigurations(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "presentationConfigurations",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });	
+		addAnnotation
+		  (getProrGeneralConfiguration_LabelConfiguration(), 
+		   source, 
+		   new String[] {
+			 "wrapperName", "labelConfiguration",
+			 "featureWrapperElement", "true",
+			 "featureElement", "false",
+			 "classifierWrapperElement", "false",
+			 "classifierElement", "true"
+		   });
+	}
+
+} //ConfigurationPackageImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/LabelConfigurationImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/LabelConfigurationImpl.java
index efd7fde..6b4ecdc 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/LabelConfigurationImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/LabelConfigurationImpl.java
@@ -1,173 +1,168 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Label Configuration</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl#getDefaultLabel <em>Default Label</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class LabelConfigurationImpl extends EObjectImpl implements LabelConfiguration {
-	/**
-	 * The cached value of the '{@link #getDefaultLabel() <em>Default Label</em>}' attribute list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDefaultLabel()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList<String> defaultLabel;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected LabelConfigurationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.LABEL_CONFIGURATION;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList<String> getDefaultLabel() {
-		if (defaultLabel == null) {
-			defaultLabel = new EDataTypeUniqueEList.Unsettable<String>(String.class, this, ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL);
-		}
-		return defaultLabel;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetDefaultLabel() {
-		if (defaultLabel != null) ((InternalEList.Unsettable<?>)defaultLabel).unset();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetDefaultLabel() {
-		return defaultLabel != null && ((InternalEList.Unsettable<?>)defaultLabel).isSet();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
-				return getDefaultLabel();
-		}
-		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 ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
-				getDefaultLabel().clear();
-				getDefaultLabel().addAll((Collection<? extends String>)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
-				unsetDefaultLabel();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
-				return isSetDefaultLabel();
-		}
-		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(" (defaultLabel: ");
-		result.append(defaultLabel);
-		result.append(')');
-		return result.toString();
-	}
-
-} //LabelConfigurationImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeUniqueEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Label Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.LabelConfigurationImpl#getDefaultLabel <em>Default Label</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class LabelConfigurationImpl extends EObjectImpl implements LabelConfiguration {
+	/**
+	 * The cached value of the '{@link #getDefaultLabel() <em>Default Label</em>}' attribute list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDefaultLabel()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<String> defaultLabel;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected LabelConfigurationImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.LABEL_CONFIGURATION;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<String> getDefaultLabel() {
+		if (defaultLabel == null) {
+			defaultLabel = new EDataTypeUniqueEList.Unsettable<String>(String.class, this, ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL);
+		}
+		return defaultLabel;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetDefaultLabel() {
+		if (defaultLabel != null) ((InternalEList.Unsettable<?>)defaultLabel).unset();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetDefaultLabel() {
+		return defaultLabel != null && ((InternalEList.Unsettable<?>)defaultLabel).isSet();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
+				return getDefaultLabel();
+		}
+		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 ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
+				getDefaultLabel().clear();
+				getDefaultLabel().addAll((Collection<? extends String>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
+				unsetDefaultLabel();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.LABEL_CONFIGURATION__DEFAULT_LABEL:
+				return isSetDefaultLabel();
+		}
+		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(" (defaultLabel: ");
+		result.append(defaultLabel);
+		result.append(')');
+		return result.toString();
+	}
+
+} //LabelConfigurationImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrGeneralConfigurationImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrGeneralConfigurationImpl.java
index 28013c0..252f4b1 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrGeneralConfigurationImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrGeneralConfigurationImpl.java
@@ -1,243 +1,237 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pror General Configuration</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl#getLabelConfiguration <em>Label Configuration</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ProrGeneralConfigurationImpl extends EObjectImpl implements ProrGeneralConfiguration {
-	/**
-	 * The cached value of the '{@link #getLabelConfiguration() <em>Label Configuration</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLabelConfiguration()
-	 * @generated
-	 * @ordered
-	 */
-	protected LabelConfiguration labelConfiguration;
-
-	/**
-	 * This is true if the Label Configuration containment reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean labelConfigurationESet;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ProrGeneralConfigurationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.PROR_GENERAL_CONFIGURATION;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public LabelConfiguration getLabelConfiguration() {
-		return labelConfiguration;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLabelConfiguration(LabelConfiguration newLabelConfiguration, NotificationChain msgs) {
-		LabelConfiguration oldLabelConfiguration = labelConfiguration;
-		labelConfiguration = newLabelConfiguration;
-		boolean oldLabelConfigurationESet = labelConfigurationESet;
-		labelConfigurationESet = true;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, oldLabelConfiguration, newLabelConfiguration, !oldLabelConfigurationESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLabelConfiguration(LabelConfiguration newLabelConfiguration) {
-		if (newLabelConfiguration != labelConfiguration) {
-			NotificationChain msgs = null;
-			if (labelConfiguration != null)
-				msgs = ((InternalEObject)labelConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, msgs);
-			if (newLabelConfiguration != null)
-				msgs = ((InternalEObject)newLabelConfiguration).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, msgs);
-			msgs = basicSetLabelConfiguration(newLabelConfiguration, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldLabelConfigurationESet = labelConfigurationESet;
-			labelConfigurationESet = true;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, newLabelConfiguration, newLabelConfiguration, !oldLabelConfigurationESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicUnsetLabelConfiguration(NotificationChain msgs) {
-		LabelConfiguration oldLabelConfiguration = labelConfiguration;
-		labelConfiguration = null;
-		boolean oldLabelConfigurationESet = labelConfigurationESet;
-		labelConfigurationESet = false;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, oldLabelConfiguration, null, oldLabelConfigurationESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetLabelConfiguration() {
-		if (labelConfiguration != null) {
-			NotificationChain msgs = null;
-			msgs = ((InternalEObject)labelConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, msgs);
-			msgs = basicUnsetLabelConfiguration(msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldLabelConfigurationESet = labelConfigurationESet;
-			labelConfigurationESet = false;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, null, oldLabelConfigurationESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetLabelConfiguration() {
-		return labelConfigurationESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
-				return basicUnsetLabelConfiguration(msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
-				return getLabelConfiguration();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
-				setLabelConfiguration((LabelConfiguration)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
-				unsetLabelConfiguration();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
-				return isSetLabelConfiguration();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ProrGeneralConfigurationImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Pror General Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrGeneralConfigurationImpl#getLabelConfiguration <em>Label Configuration</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class ProrGeneralConfigurationImpl extends EObjectImpl implements ProrGeneralConfiguration {
+	/**
+	 * The cached value of the '{@link #getLabelConfiguration() <em>Label Configuration</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLabelConfiguration()
+	 * @generated
+	 * @ordered
+	 */
+	protected LabelConfiguration labelConfiguration;
+
+	/**
+	 * This is true if the Label Configuration containment reference has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean labelConfigurationESet;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ProrGeneralConfigurationImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.PROR_GENERAL_CONFIGURATION;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public LabelConfiguration getLabelConfiguration() {
+		return labelConfiguration;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetLabelConfiguration(LabelConfiguration newLabelConfiguration, NotificationChain msgs) {
+		LabelConfiguration oldLabelConfiguration = labelConfiguration;
+		labelConfiguration = newLabelConfiguration;
+		boolean oldLabelConfigurationESet = labelConfigurationESet;
+		labelConfigurationESet = true;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, oldLabelConfiguration, newLabelConfiguration, !oldLabelConfigurationESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setLabelConfiguration(LabelConfiguration newLabelConfiguration) {
+		if (newLabelConfiguration != labelConfiguration) {
+			NotificationChain msgs = null;
+			if (labelConfiguration != null)
+				msgs = ((InternalEObject)labelConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, msgs);
+			if (newLabelConfiguration != null)
+				msgs = ((InternalEObject)newLabelConfiguration).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, msgs);
+			msgs = basicSetLabelConfiguration(newLabelConfiguration, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldLabelConfigurationESet = labelConfigurationESet;
+			labelConfigurationESet = true;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, newLabelConfiguration, newLabelConfiguration, !oldLabelConfigurationESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicUnsetLabelConfiguration(NotificationChain msgs) {
+		LabelConfiguration oldLabelConfiguration = labelConfiguration;
+		labelConfiguration = null;
+		boolean oldLabelConfigurationESet = labelConfigurationESet;
+		labelConfigurationESet = false;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, oldLabelConfiguration, null, oldLabelConfigurationESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetLabelConfiguration() {
+		if (labelConfiguration != null) {
+			NotificationChain msgs = null;
+			msgs = ((InternalEObject)labelConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, msgs);
+			msgs = basicUnsetLabelConfiguration(msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldLabelConfigurationESet = labelConfigurationESet;
+			labelConfigurationESet = false;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION, null, null, oldLabelConfigurationESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetLabelConfiguration() {
+		return labelConfigurationESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
+				return basicUnsetLabelConfiguration(msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
+				return getLabelConfiguration();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
+				setLabelConfiguration((LabelConfiguration)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
+				unsetLabelConfiguration();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION:
+				return isSetLabelConfiguration();
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //ProrGeneralConfigurationImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationImpl.java
index 338dbc2..afff36e 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationImpl.java
@@ -1,198 +1,192 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.rmf.reqif10.DatatypeDefinition;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pror Presentation Configuration</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl#getDatatype <em>Datatype</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public abstract class ProrPresentationConfigurationImpl extends EObjectImpl implements ProrPresentationConfiguration {
-	/**
-	 * The cached value of the '{@link #getDatatype() <em>Datatype</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getDatatype()
-	 * @generated
-	 * @ordered
-	 */
-	protected DatatypeDefinition datatype;
-
-	/**
-	 * This is true if the Datatype reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean datatypeESet;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ProrPresentationConfigurationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.PROR_PRESENTATION_CONFIGURATION;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DatatypeDefinition getDatatype() {
-		if (datatype != null && datatype.eIsProxy()) {
-			InternalEObject oldDatatype = (InternalEObject)datatype;
-			datatype = (DatatypeDefinition)eResolveProxy(oldDatatype);
-			if (datatype != oldDatatype) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE, oldDatatype, datatype));
-			}
-		}
-		return datatype;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public DatatypeDefinition basicGetDatatype() {
-		return datatype;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setDatatype(DatatypeDefinition newDatatype) {
-		DatatypeDefinition oldDatatype = datatype;
-		datatype = newDatatype;
-		boolean oldDatatypeESet = datatypeESet;
-		datatypeESet = true;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE, oldDatatype, datatype, !oldDatatypeESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetDatatype() {
-		DatatypeDefinition oldDatatype = datatype;
-		boolean oldDatatypeESet = datatypeESet;
-		datatype = null;
-		datatypeESet = false;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE, oldDatatype, null, oldDatatypeESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetDatatype() {
-		return datatypeESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
-				if (resolve) return getDatatype();
-				return basicGetDatatype();
-		}
-		return super.eGet(featureID, resolve, coreType);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eSet(int featureID, Object newValue) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
-				setDatatype((DatatypeDefinition)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
-				unsetDatatype();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
-				return isSetDatatype();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ProrPresentationConfigurationImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.rmf.reqif10.DatatypeDefinition;
+
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Pror Presentation Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationImpl#getDatatype <em>Datatype</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public abstract class ProrPresentationConfigurationImpl extends EObjectImpl implements ProrPresentationConfiguration {
+	/**
+	 * The cached value of the '{@link #getDatatype() <em>Datatype</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getDatatype()
+	 * @generated
+	 * @ordered
+	 */
+	protected DatatypeDefinition datatype;
+
+	/**
+	 * This is true if the Datatype reference has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean datatypeESet;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ProrPresentationConfigurationImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.PROR_PRESENTATION_CONFIGURATION;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public DatatypeDefinition getDatatype() {
+		if (datatype != null && datatype.eIsProxy()) {
+			InternalEObject oldDatatype = (InternalEObject)datatype;
+			datatype = (DatatypeDefinition)eResolveProxy(oldDatatype);
+			if (datatype != oldDatatype) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE, oldDatatype, datatype));
+			}
+		}
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public DatatypeDefinition basicGetDatatype() {
+		return datatype;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setDatatype(DatatypeDefinition newDatatype) {
+		DatatypeDefinition oldDatatype = datatype;
+		datatype = newDatatype;
+		boolean oldDatatypeESet = datatypeESet;
+		datatypeESet = true;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE, oldDatatype, datatype, !oldDatatypeESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetDatatype() {
+		DatatypeDefinition oldDatatype = datatype;
+		boolean oldDatatypeESet = datatypeESet;
+		datatype = null;
+		datatypeESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE, oldDatatype, null, oldDatatypeESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetDatatype() {
+		return datatypeESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
+				if (resolve) return getDatatype();
+				return basicGetDatatype();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
+				setDatatype((DatatypeDefinition)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
+				unsetDatatype();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION__DATATYPE:
+				return isSetDatatype();
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //ProrPresentationConfigurationImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationsImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationsImpl.java
index e2eb43e..64dec86 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationsImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrPresentationConfigurationsImpl.java
@@ -1,174 +1,170 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pror Presentation Configurations</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ProrPresentationConfigurationsImpl extends EObjectImpl implements ProrPresentationConfigurations {
-	/**
-	 * The cached value of the '{@link #getPresentationConfigurations() <em>Presentation Configurations</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPresentationConfigurations()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList<ProrPresentationConfiguration> presentationConfigurations;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ProrPresentationConfigurationsImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.PROR_PRESENTATION_CONFIGURATIONS;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList<ProrPresentationConfiguration> getPresentationConfigurations() {
-		if (presentationConfigurations == null) {
-			presentationConfigurations = new EObjectContainmentEList.Unsettable<ProrPresentationConfiguration>(ProrPresentationConfiguration.class, this, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS);
-		}
-		return presentationConfigurations;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetPresentationConfigurations() {
-		if (presentationConfigurations != null) ((InternalEList.Unsettable<?>)presentationConfigurations).unset();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetPresentationConfigurations() {
-		return presentationConfigurations != null && ((InternalEList.Unsettable<?>)presentationConfigurations).isSet();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
-				return ((InternalEList<?>)getPresentationConfigurations()).basicRemove(otherEnd, msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
-				return getPresentationConfigurations();
-		}
-		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 ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
-				getPresentationConfigurations().clear();
-				getPresentationConfigurations().addAll((Collection<? extends ProrPresentationConfiguration>)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
-				unsetPresentationConfigurations();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
-				return isSetPresentationConfigurations();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ProrPresentationConfigurationsImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Pror Presentation Configurations</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrPresentationConfigurationsImpl#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class ProrPresentationConfigurationsImpl extends EObjectImpl implements ProrPresentationConfigurations {
+	/**
+	 * The cached value of the '{@link #getPresentationConfigurations() <em>Presentation Configurations</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getPresentationConfigurations()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<ProrPresentationConfiguration> presentationConfigurations;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ProrPresentationConfigurationsImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.PROR_PRESENTATION_CONFIGURATIONS;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<ProrPresentationConfiguration> getPresentationConfigurations() {
+		if (presentationConfigurations == null) {
+			presentationConfigurations = new EObjectContainmentEList.Unsettable<ProrPresentationConfiguration>(ProrPresentationConfiguration.class, this, ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS);
+		}
+		return presentationConfigurations;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetPresentationConfigurations() {
+		if (presentationConfigurations != null) ((InternalEList.Unsettable<?>)presentationConfigurations).unset();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetPresentationConfigurations() {
+		return presentationConfigurations != null && ((InternalEList.Unsettable<?>)presentationConfigurations).isSet();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
+				return ((InternalEList<?>)getPresentationConfigurations()).basicRemove(otherEnd, msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
+				return getPresentationConfigurations();
+		}
+		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 ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
+				getPresentationConfigurations().clear();
+				getPresentationConfigurations().addAll((Collection<? extends ProrPresentationConfiguration>)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
+				unsetPresentationConfigurations();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS__PRESENTATION_CONFIGURATIONS:
+				return isSetPresentationConfigurations();
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //ProrPresentationConfigurationsImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrSpecViewConfigurationImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrSpecViewConfigurationImpl.java
index 6797911..498c0fa 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrSpecViewConfigurationImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrSpecViewConfigurationImpl.java
@@ -1,399 +1,395 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.rmf.reqif10.Specification;
-import org.eclipse.rmf.reqif10.pror.configuration.Column;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
-
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pror Spec View Configuration</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl#getSpecification <em>Specification</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl#getColumns <em>Columns</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl#getLeftHeaderColumn <em>Left Header Column</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ProrSpecViewConfigurationImpl extends EObjectImpl implements ProrSpecViewConfiguration {
-	/**
-	 * The cached value of the '{@link #getSpecification() <em>Specification</em>}' reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSpecification()
-	 * @generated
-	 * @ordered
-	 */
-	protected Specification specification;
-
-	/**
-	 * This is true if the Specification reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean specificationESet;
-
-	/**
-	 * The cached value of the '{@link #getColumns() <em>Columns</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getColumns()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList<Column> columns;
-
-	/**
-	 * The cached value of the '{@link #getLeftHeaderColumn() <em>Left Header Column</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getLeftHeaderColumn()
-	 * @generated
-	 * @ordered
-	 */
-	protected Column leftHeaderColumn;
-
-	/**
-	 * This is true if the Left Header Column containment reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean leftHeaderColumnESet;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ProrSpecViewConfigurationImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.PROR_SPEC_VIEW_CONFIGURATION;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Specification getSpecification() {
-		if (specification != null && specification.eIsProxy()) {
-			InternalEObject oldSpecification = (InternalEObject)specification;
-			specification = (Specification)eResolveProxy(oldSpecification);
-			if (specification != oldSpecification) {
-				if (eNotificationRequired())
-					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION, oldSpecification, specification));
-			}
-		}
-		return specification;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Specification basicGetSpecification() {
-		return specification;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setSpecification(Specification newSpecification) {
-		Specification oldSpecification = specification;
-		specification = newSpecification;
-		boolean oldSpecificationESet = specificationESet;
-		specificationESet = true;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION, oldSpecification, specification, !oldSpecificationESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetSpecification() {
-		Specification oldSpecification = specification;
-		boolean oldSpecificationESet = specificationESet;
-		specification = null;
-		specificationESet = false;
-		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION, oldSpecification, null, oldSpecificationESet));
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetSpecification() {
-		return specificationESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList<Column> getColumns() {
-		if (columns == null) {
-			columns = new EObjectContainmentEList.Unsettable<Column>(Column.class, this, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS);
-		}
-		return columns;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetColumns() {
-		if (columns != null) ((InternalEList.Unsettable<?>)columns).unset();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetColumns() {
-		return columns != null && ((InternalEList.Unsettable<?>)columns).isSet();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public Column getLeftHeaderColumn() {
-		return leftHeaderColumn;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetLeftHeaderColumn(Column newLeftHeaderColumn, NotificationChain msgs) {
-		Column oldLeftHeaderColumn = leftHeaderColumn;
-		leftHeaderColumn = newLeftHeaderColumn;
-		boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
-		leftHeaderColumnESet = true;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, oldLeftHeaderColumn, newLeftHeaderColumn, !oldLeftHeaderColumnESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setLeftHeaderColumn(Column newLeftHeaderColumn) {
-		if (newLeftHeaderColumn != leftHeaderColumn) {
-			NotificationChain msgs = null;
-			if (leftHeaderColumn != null)
-				msgs = ((InternalEObject)leftHeaderColumn).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, msgs);
-			if (newLeftHeaderColumn != null)
-				msgs = ((InternalEObject)newLeftHeaderColumn).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, msgs);
-			msgs = basicSetLeftHeaderColumn(newLeftHeaderColumn, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
-			leftHeaderColumnESet = true;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, newLeftHeaderColumn, newLeftHeaderColumn, !oldLeftHeaderColumnESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicUnsetLeftHeaderColumn(NotificationChain msgs) {
-		Column oldLeftHeaderColumn = leftHeaderColumn;
-		leftHeaderColumn = null;
-		boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
-		leftHeaderColumnESet = false;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, oldLeftHeaderColumn, null, oldLeftHeaderColumnESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetLeftHeaderColumn() {
-		if (leftHeaderColumn != null) {
-			NotificationChain msgs = null;
-			msgs = ((InternalEObject)leftHeaderColumn).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, msgs);
-			msgs = basicUnsetLeftHeaderColumn(msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
-			leftHeaderColumnESet = false;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, null, oldLeftHeaderColumnESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetLeftHeaderColumn() {
-		return leftHeaderColumnESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
-				return ((InternalEList<?>)getColumns()).basicRemove(otherEnd, msgs);
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
-				return basicUnsetLeftHeaderColumn(msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
-				if (resolve) return getSpecification();
-				return basicGetSpecification();
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
-				return getColumns();
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
-				return getLeftHeaderColumn();
-		}
-		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 ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
-				setSpecification((Specification)newValue);
-				return;
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
-				getColumns().clear();
-				getColumns().addAll((Collection<? extends Column>)newValue);
-				return;
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
-				setLeftHeaderColumn((Column)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
-				unsetSpecification();
-				return;
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
-				unsetColumns();
-				return;
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
-				unsetLeftHeaderColumn();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
-				return isSetSpecification();
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
-				return isSetColumns();
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
-				return isSetLeftHeaderColumn();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ProrSpecViewConfigurationImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.rmf.reqif10.Specification;
+
+import org.eclipse.rmf.reqif10.pror.configuration.Column;
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Pror Spec View Configuration</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl#getSpecification <em>Specification</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl#getColumns <em>Columns</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrSpecViewConfigurationImpl#getLeftHeaderColumn <em>Left Header Column</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class ProrSpecViewConfigurationImpl extends EObjectImpl implements ProrSpecViewConfiguration {
+	/**
+	 * The cached value of the '{@link #getSpecification() <em>Specification</em>}' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSpecification()
+	 * @generated
+	 * @ordered
+	 */
+	protected Specification specification;
+
+	/**
+	 * This is true if the Specification reference has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean specificationESet;
+
+	/**
+	 * The cached value of the '{@link #getColumns() <em>Columns</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getColumns()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<Column> columns;
+
+	/**
+	 * The cached value of the '{@link #getLeftHeaderColumn() <em>Left Header Column</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLeftHeaderColumn()
+	 * @generated
+	 * @ordered
+	 */
+	protected Column leftHeaderColumn;
+
+	/**
+	 * This is true if the Left Header Column containment reference has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean leftHeaderColumnESet;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ProrSpecViewConfigurationImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.PROR_SPEC_VIEW_CONFIGURATION;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Specification getSpecification() {
+		if (specification != null && specification.eIsProxy()) {
+			InternalEObject oldSpecification = (InternalEObject)specification;
+			specification = (Specification)eResolveProxy(oldSpecification);
+			if (specification != oldSpecification) {
+				if (eNotificationRequired())
+					eNotify(new ENotificationImpl(this, Notification.RESOLVE, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION, oldSpecification, specification));
+			}
+		}
+		return specification;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Specification basicGetSpecification() {
+		return specification;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSpecification(Specification newSpecification) {
+		Specification oldSpecification = specification;
+		specification = newSpecification;
+		boolean oldSpecificationESet = specificationESet;
+		specificationESet = true;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION, oldSpecification, specification, !oldSpecificationESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetSpecification() {
+		Specification oldSpecification = specification;
+		boolean oldSpecificationESet = specificationESet;
+		specification = null;
+		specificationESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION, oldSpecification, null, oldSpecificationESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetSpecification() {
+		return specificationESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<Column> getColumns() {
+		if (columns == null) {
+			columns = new EObjectContainmentEList.Unsettable<Column>(Column.class, this, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS);
+		}
+		return columns;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetColumns() {
+		if (columns != null) ((InternalEList.Unsettable<?>)columns).unset();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetColumns() {
+		return columns != null && ((InternalEList.Unsettable<?>)columns).isSet();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public Column getLeftHeaderColumn() {
+		return leftHeaderColumn;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetLeftHeaderColumn(Column newLeftHeaderColumn, NotificationChain msgs) {
+		Column oldLeftHeaderColumn = leftHeaderColumn;
+		leftHeaderColumn = newLeftHeaderColumn;
+		boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
+		leftHeaderColumnESet = true;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, oldLeftHeaderColumn, newLeftHeaderColumn, !oldLeftHeaderColumnESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setLeftHeaderColumn(Column newLeftHeaderColumn) {
+		if (newLeftHeaderColumn != leftHeaderColumn) {
+			NotificationChain msgs = null;
+			if (leftHeaderColumn != null)
+				msgs = ((InternalEObject)leftHeaderColumn).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, msgs);
+			if (newLeftHeaderColumn != null)
+				msgs = ((InternalEObject)newLeftHeaderColumn).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, msgs);
+			msgs = basicSetLeftHeaderColumn(newLeftHeaderColumn, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
+			leftHeaderColumnESet = true;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, newLeftHeaderColumn, newLeftHeaderColumn, !oldLeftHeaderColumnESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicUnsetLeftHeaderColumn(NotificationChain msgs) {
+		Column oldLeftHeaderColumn = leftHeaderColumn;
+		leftHeaderColumn = null;
+		boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
+		leftHeaderColumnESet = false;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, oldLeftHeaderColumn, null, oldLeftHeaderColumnESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetLeftHeaderColumn() {
+		if (leftHeaderColumn != null) {
+			NotificationChain msgs = null;
+			msgs = ((InternalEObject)leftHeaderColumn).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, msgs);
+			msgs = basicUnsetLeftHeaderColumn(msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldLeftHeaderColumnESet = leftHeaderColumnESet;
+			leftHeaderColumnESet = false;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN, null, null, oldLeftHeaderColumnESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetLeftHeaderColumn() {
+		return leftHeaderColumnESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
+				return ((InternalEList<?>)getColumns()).basicRemove(otherEnd, msgs);
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
+				return basicUnsetLeftHeaderColumn(msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
+				if (resolve) return getSpecification();
+				return basicGetSpecification();
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
+				return getColumns();
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
+				return getLeftHeaderColumn();
+		}
+		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 ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
+				setSpecification((Specification)newValue);
+				return;
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
+				getColumns().clear();
+				getColumns().addAll((Collection<? extends Column>)newValue);
+				return;
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
+				setLeftHeaderColumn((Column)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
+				unsetSpecification();
+				return;
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
+				unsetColumns();
+				return;
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
+				unsetLeftHeaderColumn();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__SPECIFICATION:
+				return isSetSpecification();
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__COLUMNS:
+				return isSetColumns();
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION__LEFT_HEADER_COLUMN:
+				return isSetLeftHeaderColumn();
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //ProrSpecViewConfigurationImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrToolExtensionImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrToolExtensionImpl.java
index eb4e49b..162e5c4 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrToolExtensionImpl.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/impl/ProrToolExtensionImpl.java
@@ -1,433 +1,428 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.impl;
-
-import java.util.Collection;
-
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.impl.EObjectImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pror Tool Extension</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl#getSpecViewConfigurations <em>Spec View Configurations</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl#getGeneralConfiguration <em>General Configuration</em>}</li>
- *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ProrToolExtensionImpl extends EObjectImpl implements ProrToolExtension {
-	/**
-	 * The cached value of the '{@link #getSpecViewConfigurations() <em>Spec View Configurations</em>}' containment reference list.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getSpecViewConfigurations()
-	 * @generated
-	 * @ordered
-	 */
-	protected EList<ProrSpecViewConfiguration> specViewConfigurations;
-
-	/**
-	 * The cached value of the '{@link #getGeneralConfiguration() <em>General Configuration</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getGeneralConfiguration()
-	 * @generated
-	 * @ordered
-	 */
-	protected ProrGeneralConfiguration generalConfiguration;
-
-	/**
-	 * This is true if the General Configuration containment reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean generalConfigurationESet;
-
-	/**
-	 * The cached value of the '{@link #getPresentationConfigurations() <em>Presentation Configurations</em>}' containment reference.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @see #getPresentationConfigurations()
-	 * @generated
-	 * @ordered
-	 */
-	protected ProrPresentationConfigurations presentationConfigurations;
-
-	/**
-	 * This is true if the Presentation Configurations containment reference has been set.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 * @ordered
-	 */
-	protected boolean presentationConfigurationsESet;
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * Set to public, so that the framework can instantiate this class.
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public ProrToolExtensionImpl() {
-		super();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected EClass eStaticClass() {
-		return ConfigurationPackage.Literals.PROR_TOOL_EXTENSION;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public EList<ProrSpecViewConfiguration> getSpecViewConfigurations() {
-		if (specViewConfigurations == null) {
-			specViewConfigurations = new EObjectContainmentEList.Unsettable<ProrSpecViewConfiguration>(ProrSpecViewConfiguration.class, this, ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS);
-		}
-		return specViewConfigurations;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetSpecViewConfigurations() {
-		if (specViewConfigurations != null) ((InternalEList.Unsettable<?>)specViewConfigurations).unset();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetSpecViewConfigurations() {
-		return specViewConfigurations != null && ((InternalEList.Unsettable<?>)specViewConfigurations).isSet();
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProrGeneralConfiguration getGeneralConfiguration() {
-		return generalConfiguration;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetGeneralConfiguration(ProrGeneralConfiguration newGeneralConfiguration, NotificationChain msgs) {
-		ProrGeneralConfiguration oldGeneralConfiguration = generalConfiguration;
-		generalConfiguration = newGeneralConfiguration;
-		boolean oldGeneralConfigurationESet = generalConfigurationESet;
-		generalConfigurationESet = true;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, oldGeneralConfiguration, newGeneralConfiguration, !oldGeneralConfigurationESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setGeneralConfiguration(ProrGeneralConfiguration newGeneralConfiguration) {
-		if (newGeneralConfiguration != generalConfiguration) {
-			NotificationChain msgs = null;
-			if (generalConfiguration != null)
-				msgs = ((InternalEObject)generalConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, msgs);
-			if (newGeneralConfiguration != null)
-				msgs = ((InternalEObject)newGeneralConfiguration).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, msgs);
-			msgs = basicSetGeneralConfiguration(newGeneralConfiguration, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldGeneralConfigurationESet = generalConfigurationESet;
-			generalConfigurationESet = true;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, newGeneralConfiguration, newGeneralConfiguration, !oldGeneralConfigurationESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicUnsetGeneralConfiguration(NotificationChain msgs) {
-		ProrGeneralConfiguration oldGeneralConfiguration = generalConfiguration;
-		generalConfiguration = null;
-		boolean oldGeneralConfigurationESet = generalConfigurationESet;
-		generalConfigurationESet = false;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, oldGeneralConfiguration, null, oldGeneralConfigurationESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetGeneralConfiguration() {
-		if (generalConfiguration != null) {
-			NotificationChain msgs = null;
-			msgs = ((InternalEObject)generalConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, msgs);
-			msgs = basicUnsetGeneralConfiguration(msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldGeneralConfigurationESet = generalConfigurationESet;
-			generalConfigurationESet = false;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, null, oldGeneralConfigurationESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetGeneralConfiguration() {
-		return generalConfigurationESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ProrPresentationConfigurations getPresentationConfigurations() {
-		return presentationConfigurations;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicSetPresentationConfigurations(ProrPresentationConfigurations newPresentationConfigurations, NotificationChain msgs) {
-		ProrPresentationConfigurations oldPresentationConfigurations = presentationConfigurations;
-		presentationConfigurations = newPresentationConfigurations;
-		boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
-		presentationConfigurationsESet = true;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, oldPresentationConfigurations, newPresentationConfigurations, !oldPresentationConfigurationsESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void setPresentationConfigurations(ProrPresentationConfigurations newPresentationConfigurations) {
-		if (newPresentationConfigurations != presentationConfigurations) {
-			NotificationChain msgs = null;
-			if (presentationConfigurations != null)
-				msgs = ((InternalEObject)presentationConfigurations).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, msgs);
-			if (newPresentationConfigurations != null)
-				msgs = ((InternalEObject)newPresentationConfigurations).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, msgs);
-			msgs = basicSetPresentationConfigurations(newPresentationConfigurations, msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
-			presentationConfigurationsESet = true;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, newPresentationConfigurations, newPresentationConfigurations, !oldPresentationConfigurationsESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public NotificationChain basicUnsetPresentationConfigurations(NotificationChain msgs) {
-		ProrPresentationConfigurations oldPresentationConfigurations = presentationConfigurations;
-		presentationConfigurations = null;
-		boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
-		presentationConfigurationsESet = false;
-		if (eNotificationRequired()) {
-			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, oldPresentationConfigurations, null, oldPresentationConfigurationsESet);
-			if (msgs == null) msgs = notification; else msgs.add(notification);
-		}
-		return msgs;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public void unsetPresentationConfigurations() {
-		if (presentationConfigurations != null) {
-			NotificationChain msgs = null;
-			msgs = ((InternalEObject)presentationConfigurations).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, msgs);
-			msgs = basicUnsetPresentationConfigurations(msgs);
-			if (msgs != null) msgs.dispatch();
-		}
-		else {
-			boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
-			presentationConfigurationsESet = false;
-			if (eNotificationRequired())
-				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, null, oldPresentationConfigurationsESet));
-		}
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public boolean isSetPresentationConfigurations() {
-		return presentationConfigurationsESet;
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
-				return ((InternalEList<?>)getSpecViewConfigurations()).basicRemove(otherEnd, msgs);
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
-				return basicUnsetGeneralConfiguration(msgs);
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
-				return basicUnsetPresentationConfigurations(msgs);
-		}
-		return super.eInverseRemove(otherEnd, featureID, msgs);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Object eGet(int featureID, boolean resolve, boolean coreType) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
-				return getSpecViewConfigurations();
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
-				return getGeneralConfiguration();
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
-				return getPresentationConfigurations();
-		}
-		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 ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
-				getSpecViewConfigurations().clear();
-				getSpecViewConfigurations().addAll((Collection<? extends ProrSpecViewConfiguration>)newValue);
-				return;
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
-				setGeneralConfiguration((ProrGeneralConfiguration)newValue);
-				return;
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
-				setPresentationConfigurations((ProrPresentationConfigurations)newValue);
-				return;
-		}
-		super.eSet(featureID, newValue);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public void eUnset(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
-				unsetSpecViewConfigurations();
-				return;
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
-				unsetGeneralConfiguration();
-				return;
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
-				unsetPresentationConfigurations();
-				return;
-		}
-		super.eUnset(featureID);
-	}
-
-	/**
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public boolean eIsSet(int featureID) {
-		switch (featureID) {
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
-				return isSetSpecViewConfigurations();
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
-				return isSetGeneralConfiguration();
-			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
-				return isSetPresentationConfigurations();
-		}
-		return super.eIsSet(featureID);
-	}
-
-} //ProrToolExtensionImpl
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.EObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
+import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Pror Tool Extension</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl#getSpecViewConfigurations <em>Spec View Configurations</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl#getGeneralConfiguration <em>General Configuration</em>}</li>
+ *   <li>{@link org.eclipse.rmf.reqif10.pror.configuration.impl.ProrToolExtensionImpl#getPresentationConfigurations <em>Presentation Configurations</em>}</li>
+ * </ul>
+ * </p>
+ *
+ * @generated
+ */
+public class ProrToolExtensionImpl extends EObjectImpl implements ProrToolExtension {
+	/**
+	 * The cached value of the '{@link #getSpecViewConfigurations() <em>Spec View Configurations</em>}' containment reference list.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSpecViewConfigurations()
+	 * @generated
+	 * @ordered
+	 */
+	protected EList<ProrSpecViewConfiguration> specViewConfigurations;
+
+	/**
+	 * The cached value of the '{@link #getGeneralConfiguration() <em>General Configuration</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getGeneralConfiguration()
+	 * @generated
+	 * @ordered
+	 */
+	protected ProrGeneralConfiguration generalConfiguration;
+
+	/**
+	 * This is true if the General Configuration containment reference has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean generalConfigurationESet;
+
+	/**
+	 * The cached value of the '{@link #getPresentationConfigurations() <em>Presentation Configurations</em>}' containment reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getPresentationConfigurations()
+	 * @generated
+	 * @ordered
+	 */
+	protected ProrPresentationConfigurations presentationConfigurations;
+
+	/**
+	 * This is true if the Presentation Configurations containment reference has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean presentationConfigurationsESet;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ProrToolExtensionImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return ConfigurationPackage.Literals.PROR_TOOL_EXTENSION;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EList<ProrSpecViewConfiguration> getSpecViewConfigurations() {
+		if (specViewConfigurations == null) {
+			specViewConfigurations = new EObjectContainmentEList.Unsettable<ProrSpecViewConfiguration>(ProrSpecViewConfiguration.class, this, ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS);
+		}
+		return specViewConfigurations;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetSpecViewConfigurations() {
+		if (specViewConfigurations != null) ((InternalEList.Unsettable<?>)specViewConfigurations).unset();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetSpecViewConfigurations() {
+		return specViewConfigurations != null && ((InternalEList.Unsettable<?>)specViewConfigurations).isSet();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ProrGeneralConfiguration getGeneralConfiguration() {
+		return generalConfiguration;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetGeneralConfiguration(ProrGeneralConfiguration newGeneralConfiguration, NotificationChain msgs) {
+		ProrGeneralConfiguration oldGeneralConfiguration = generalConfiguration;
+		generalConfiguration = newGeneralConfiguration;
+		boolean oldGeneralConfigurationESet = generalConfigurationESet;
+		generalConfigurationESet = true;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, oldGeneralConfiguration, newGeneralConfiguration, !oldGeneralConfigurationESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setGeneralConfiguration(ProrGeneralConfiguration newGeneralConfiguration) {
+		if (newGeneralConfiguration != generalConfiguration) {
+			NotificationChain msgs = null;
+			if (generalConfiguration != null)
+				msgs = ((InternalEObject)generalConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, msgs);
+			if (newGeneralConfiguration != null)
+				msgs = ((InternalEObject)newGeneralConfiguration).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, msgs);
+			msgs = basicSetGeneralConfiguration(newGeneralConfiguration, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldGeneralConfigurationESet = generalConfigurationESet;
+			generalConfigurationESet = true;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, newGeneralConfiguration, newGeneralConfiguration, !oldGeneralConfigurationESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicUnsetGeneralConfiguration(NotificationChain msgs) {
+		ProrGeneralConfiguration oldGeneralConfiguration = generalConfiguration;
+		generalConfiguration = null;
+		boolean oldGeneralConfigurationESet = generalConfigurationESet;
+		generalConfigurationESet = false;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, oldGeneralConfiguration, null, oldGeneralConfigurationESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetGeneralConfiguration() {
+		if (generalConfiguration != null) {
+			NotificationChain msgs = null;
+			msgs = ((InternalEObject)generalConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, msgs);
+			msgs = basicUnsetGeneralConfiguration(msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldGeneralConfigurationESet = generalConfigurationESet;
+			generalConfigurationESet = false;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION, null, null, oldGeneralConfigurationESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetGeneralConfiguration() {
+		return generalConfigurationESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ProrPresentationConfigurations getPresentationConfigurations() {
+		return presentationConfigurations;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicSetPresentationConfigurations(ProrPresentationConfigurations newPresentationConfigurations, NotificationChain msgs) {
+		ProrPresentationConfigurations oldPresentationConfigurations = presentationConfigurations;
+		presentationConfigurations = newPresentationConfigurations;
+		boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
+		presentationConfigurationsESet = true;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, oldPresentationConfigurations, newPresentationConfigurations, !oldPresentationConfigurationsESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setPresentationConfigurations(ProrPresentationConfigurations newPresentationConfigurations) {
+		if (newPresentationConfigurations != presentationConfigurations) {
+			NotificationChain msgs = null;
+			if (presentationConfigurations != null)
+				msgs = ((InternalEObject)presentationConfigurations).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, msgs);
+			if (newPresentationConfigurations != null)
+				msgs = ((InternalEObject)newPresentationConfigurations).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, msgs);
+			msgs = basicSetPresentationConfigurations(newPresentationConfigurations, msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
+			presentationConfigurationsESet = true;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.SET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, newPresentationConfigurations, newPresentationConfigurations, !oldPresentationConfigurationsESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public NotificationChain basicUnsetPresentationConfigurations(NotificationChain msgs) {
+		ProrPresentationConfigurations oldPresentationConfigurations = presentationConfigurations;
+		presentationConfigurations = null;
+		boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
+		presentationConfigurationsESet = false;
+		if (eNotificationRequired()) {
+			ENotificationImpl notification = new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, oldPresentationConfigurations, null, oldPresentationConfigurationsESet);
+			if (msgs == null) msgs = notification; else msgs.add(notification);
+		}
+		return msgs;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void unsetPresentationConfigurations() {
+		if (presentationConfigurations != null) {
+			NotificationChain msgs = null;
+			msgs = ((InternalEObject)presentationConfigurations).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, msgs);
+			msgs = basicUnsetPresentationConfigurations(msgs);
+			if (msgs != null) msgs.dispatch();
+		}
+		else {
+			boolean oldPresentationConfigurationsESet = presentationConfigurationsESet;
+			presentationConfigurationsESet = false;
+			if (eNotificationRequired())
+				eNotify(new ENotificationImpl(this, Notification.UNSET, ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS, null, null, oldPresentationConfigurationsESet));
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSetPresentationConfigurations() {
+		return presentationConfigurationsESet;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
+				return ((InternalEList<?>)getSpecViewConfigurations()).basicRemove(otherEnd, msgs);
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
+				return basicUnsetGeneralConfiguration(msgs);
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
+				return basicUnsetPresentationConfigurations(msgs);
+		}
+		return super.eInverseRemove(otherEnd, featureID, msgs);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
+				return getSpecViewConfigurations();
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
+				return getGeneralConfiguration();
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
+				return getPresentationConfigurations();
+		}
+		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 ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
+				getSpecViewConfigurations().clear();
+				getSpecViewConfigurations().addAll((Collection<? extends ProrSpecViewConfiguration>)newValue);
+				return;
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
+				setGeneralConfiguration((ProrGeneralConfiguration)newValue);
+				return;
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
+				setPresentationConfigurations((ProrPresentationConfigurations)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
+				unsetSpecViewConfigurations();
+				return;
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
+				unsetGeneralConfiguration();
+				return;
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
+				unsetPresentationConfigurations();
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__SPEC_VIEW_CONFIGURATIONS:
+				return isSetSpecViewConfigurations();
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION:
+				return isSetGeneralConfiguration();
+			case ConfigurationPackage.PROR_TOOL_EXTENSION__PRESENTATION_CONFIGURATIONS:
+				return isSetPresentationConfigurations();
+		}
+		return super.eIsSet(featureID);
+	}
+
+} //ProrToolExtensionImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationAdapterFactory.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationAdapterFactory.java
index f829246..20bd688 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationAdapterFactory.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationAdapterFactory.java
@@ -1,260 +1,246 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.util;
-
-import org.eclipse.emf.common.notify.Adapter;
-import org.eclipse.emf.common.notify.Notifier;
-import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.rmf.reqif10.pror.configuration.*;
-import org.eclipse.rmf.reqif10.pror.configuration.Column;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Adapter Factory</b> for the model.
- * It provides an adapter <code>createXXX</code> method for each class of the model.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage
- * @generated
- */
-public class ConfigurationAdapterFactory extends AdapterFactoryImpl {
-	/**
-	 * The cached model package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected static ConfigurationPackage modelPackage;
-
-	/**
-	 * Creates an instance of the adapter factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationAdapterFactory() {
-		if (modelPackage == null) {
-			modelPackage = ConfigurationPackage.eINSTANCE;
-		}
-	}
-
-	/**
-	 * Returns whether this factory is applicable for the type of the object.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
-	 * <!-- end-user-doc -->
-	 * @return whether this factory is applicable for the type of the object.
-	 * @generated
-	 */
-	@Override
-	public boolean isFactoryForType(Object object) {
-		if (object == modelPackage) {
-			return true;
-		}
-		if (object instanceof EObject) {
-			return ((EObject)object).eClass().getEPackage() == modelPackage;
-		}
-		return false;
-	}
-
-	/**
-	 * The switch that delegates to the <code>createXXX</code> methods.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected ConfigurationSwitch<Adapter> modelSwitch =
-		new ConfigurationSwitch<Adapter>() {
-			@Override
-			public Adapter caseProrToolExtension(ProrToolExtension object) {
-				return createProrToolExtensionAdapter();
-			}
-			@Override
-			public Adapter caseProrSpecViewConfiguration(ProrSpecViewConfiguration object) {
-				return createProrSpecViewConfigurationAdapter();
-			}
-			@Override
-			public Adapter caseColumn(Column object) {
-				return createColumnAdapter();
-			}
-			@Override
-			public Adapter caseProrPresentationConfigurations(ProrPresentationConfigurations object) {
-				return createProrPresentationConfigurationsAdapter();
-			}
-			@Override
-			public Adapter caseProrPresentationConfiguration(ProrPresentationConfiguration object) {
-				return createProrPresentationConfigurationAdapter();
-			}
-			@Override
-			public Adapter caseProrGeneralConfiguration(ProrGeneralConfiguration object) {
-				return createProrGeneralConfigurationAdapter();
-			}
-			@Override
-			public Adapter caseLabelConfiguration(LabelConfiguration object) {
-				return createLabelConfigurationAdapter();
-			}
-			@Override
-			public Adapter caseUnifiedColumn(UnifiedColumn object) {
-				return createUnifiedColumnAdapter();
-			}
-			@Override
-			public Adapter defaultCase(EObject object) {
-				return createEObjectAdapter();
-			}
-		};
-
-	/**
-	 * Creates an adapter for the <code>target</code>.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param target the object to adapt.
-	 * @return the adapter for the <code>target</code>.
-	 * @generated
-	 */
-	@Override
-	public Adapter createAdapter(Notifier target) {
-		return modelSwitch.doSwitch((EObject)target);
-	}
-
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension <em>Pror Tool Extension</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.rmf.reqif10.pror.configuration.ProrToolExtension
-	 * @generated
-	 */
-	public Adapter createProrToolExtensionAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration <em>Pror Spec View Configuration</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.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration
-	 * @generated
-	 */
-	public Adapter createProrSpecViewConfigurationAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.Column <em>Column</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.rmf.reqif10.pror.configuration.Column
-	 * @generated
-	 */
-	public Adapter createColumnAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations <em>Pror Presentation Configurations</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.rmf.reqif10.pror.configuration.ProrPresentationConfigurations
-	 * @generated
-	 */
-	public Adapter createProrPresentationConfigurationsAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration <em>Pror Presentation Configuration</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.rmf.reqif10.pror.configuration.ProrPresentationConfiguration
-	 * @generated
-	 */
-	public Adapter createProrPresentationConfigurationAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration <em>Pror General Configuration</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.rmf.reqif10.pror.configuration.ProrGeneralConfiguration
-	 * @generated
-	 */
-	public Adapter createProrGeneralConfigurationAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration <em>Label Configuration</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.rmf.reqif10.pror.configuration.LabelConfiguration
-	 * @generated
-	 */
-	public Adapter createLabelConfigurationAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn <em>Unified Column</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.rmf.reqif10.pror.configuration.UnifiedColumn
-	 * @generated
-	 */
-	public Adapter createUnifiedColumnAdapter() {
-		return null;
-	}
-
-	/**
-	 * Creates a new adapter for the default case.
-	 * <!-- begin-user-doc -->
-	 * This default implementation returns null.
-	 * <!-- end-user-doc -->
-	 * @return the new adapter.
-	 * @generated
-	 */
-	public Adapter createEObjectAdapter() {
-		return null;
-	}
-
-} //ConfigAdapterFactory
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.rmf.reqif10.pror.configuration.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage
+ * @generated
+ */
+public class ConfigurationAdapterFactory extends AdapterFactoryImpl {
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static ConfigurationPackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ConfigurationAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = ConfigurationPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+	 * <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected ConfigurationSwitch<Adapter> modelSwitch =
+		new ConfigurationSwitch<Adapter>() {
+			@Override
+			public Adapter caseProrToolExtension(ProrToolExtension object) {
+				return createProrToolExtensionAdapter();
+			}
+			@Override
+			public Adapter caseProrSpecViewConfiguration(ProrSpecViewConfiguration object) {
+				return createProrSpecViewConfigurationAdapter();
+			}
+			@Override
+			public Adapter caseColumn(Column object) {
+				return createColumnAdapter();
+			}
+			@Override
+			public Adapter caseProrPresentationConfigurations(ProrPresentationConfigurations object) {
+				return createProrPresentationConfigurationsAdapter();
+			}
+			@Override
+			public Adapter caseProrPresentationConfiguration(ProrPresentationConfiguration object) {
+				return createProrPresentationConfigurationAdapter();
+			}
+			@Override
+			public Adapter caseProrGeneralConfiguration(ProrGeneralConfiguration object) {
+				return createProrGeneralConfigurationAdapter();
+			}
+			@Override
+			public Adapter caseLabelConfiguration(LabelConfiguration object) {
+				return createLabelConfigurationAdapter();
+			}
+			@Override
+			public Adapter caseUnifiedColumn(UnifiedColumn object) {
+				return createUnifiedColumnAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension <em>Pror Tool Extension</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.rmf.reqif10.pror.configuration.ProrToolExtension
+	 * @generated
+	 */
+	public Adapter createProrToolExtensionAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration <em>Pror Spec View Configuration</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.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration
+	 * @generated
+	 */
+	public Adapter createProrSpecViewConfigurationAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.Column <em>Column</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.rmf.reqif10.pror.configuration.Column
+	 * @generated
+	 */
+	public Adapter createColumnAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations <em>Pror Presentation Configurations</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.rmf.reqif10.pror.configuration.ProrPresentationConfigurations
+	 * @generated
+	 */
+	public Adapter createProrPresentationConfigurationsAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration <em>Pror Presentation Configuration</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.rmf.reqif10.pror.configuration.ProrPresentationConfiguration
+	 * @generated
+	 */
+	public Adapter createProrPresentationConfigurationAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration <em>Pror General Configuration</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.rmf.reqif10.pror.configuration.ProrGeneralConfiguration
+	 * @generated
+	 */
+	public Adapter createProrGeneralConfigurationAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration <em>Label Configuration</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.rmf.reqif10.pror.configuration.LabelConfiguration
+	 * @generated
+	 */
+	public Adapter createLabelConfigurationAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.rmf.reqif10.pror.configuration.UnifiedColumn <em>Unified Column</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.rmf.reqif10.pror.configuration.UnifiedColumn
+	 * @generated
+	 */
+	public Adapter createUnifiedColumnAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+} //ConfigurationAdapterFactory
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationResourceFactoryImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationResourceFactoryImpl.java
deleted file mode 100644
index 7cf92a7..0000000
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationResourceFactoryImpl.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * <copyright>
- * </copyright>
- *
- * $Id$
- */
-package org.eclipse.rmf.reqif10.pror.configuration.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl;
-import org.eclipse.emf.ecore.xmi.XMLResource;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource Factory</b> associated with the package.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.reqif10.pror.configuration.util.ConfigurationResourceImpl
- * @generated
- */
-public class ConfigurationResourceFactoryImpl extends ResourceFactoryImpl {
-	/**
-	 * Creates an instance of the resource factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationResourceFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * Creates an instance of the resource.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	public Resource createResource(URI uri) {
-		XMLResource result = new ConfigurationResourceImpl(uri);
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
-
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_SCHEMA_LOCATION, Boolean.TRUE);
-
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_USE_LEXICAL_HANDLER, Boolean.TRUE);
-		return result;
-	}
-
-} //ConfigurationResourceFactoryImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationResourceImpl.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationResourceImpl.java
deleted file mode 100644
index 0e1ad84..0000000
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationResourceImpl.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * <copyright>
- * </copyright>
- *
- * $Id$
- */
-package org.eclipse.rmf.reqif10.pror.configuration.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl;
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Resource </b> associated with the package.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.reqif10.pror.configuration.util.ConfigurationResourceFactoryImpl
- * @generated
- */
-public class ConfigurationResourceImpl extends XMLResourceImpl {
-	/**
-	 * Creates an instance of the resource.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @param uri the URI of the new resource.
-	 * @generated
-	 */
-	public ConfigurationResourceImpl(URI uri) {
-		super(uri);
-	}
-
-} //ConfigurationResourceImpl
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationSwitch.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationSwitch.java
index 01a0ae8..fe3c828 100644
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationSwitch.java
+++ b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationSwitch.java
@@ -1,274 +1,258 @@
-/*******************************************************************************
- * Copyright (c) 2011, 2013 Formal Mind GmbH and University of Dusseldorf.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Michael Jastram - initial API and implementation
- ******************************************************************************/
-
-package org.eclipse.rmf.reqif10.pror.configuration.util;
-
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.util.Switch;
-import org.eclipse.rmf.reqif10.pror.configuration.*;
-import org.eclipse.rmf.reqif10.pror.configuration.Column;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-import org.eclipse.rmf.reqif10.pror.configuration.LabelConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrGeneralConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrPresentationConfigurations;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrSpecViewConfiguration;
-import org.eclipse.rmf.reqif10.pror.configuration.ProrToolExtension;
-
-
-/**
- * <!-- begin-user-doc -->
- * The <b>Switch</b> for the model's inheritance hierarchy.
- * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
- * to invoke the <code>caseXXX</code> method for each class of the model,
- * starting with the actual class of the object
- * and proceeding up the inheritance hierarchy
- * until a non-null result is returned,
- * which is the result of the switch.
- * <!-- end-user-doc -->
- * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage
- * @generated
- */
-public class ConfigurationSwitch<T> extends Switch<T> {
-	/**
-	 * The cached model package
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	protected static ConfigurationPackage modelPackage;
-
-	/**
-	 * Creates an instance of the switch.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationSwitch() {
-		if (modelPackage == null) {
-			modelPackage = ConfigurationPackage.eINSTANCE;
-		}
-	}
-
-	/**
-	 * Checks whether this is a switch for the given package.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @parameter ePackage the package in question.
-	 * @return whether this is a switch for the given package.
-	 * @generated
-	 */
-	@Override
-	protected boolean isSwitchFor(EPackage ePackage) {
-		return ePackage == modelPackage;
-	}
-
-	/**
-	 * 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 ConfigurationPackage.PROR_TOOL_EXTENSION: {
-				ProrToolExtension prorToolExtension = (ProrToolExtension)theEObject;
-				T result = caseProrToolExtension(prorToolExtension);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION: {
-				ProrSpecViewConfiguration prorSpecViewConfiguration = (ProrSpecViewConfiguration)theEObject;
-				T result = caseProrSpecViewConfiguration(prorSpecViewConfiguration);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.COLUMN: {
-				Column column = (Column)theEObject;
-				T result = caseColumn(column);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS: {
-				ProrPresentationConfigurations prorPresentationConfigurations = (ProrPresentationConfigurations)theEObject;
-				T result = caseProrPresentationConfigurations(prorPresentationConfigurations);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION: {
-				ProrPresentationConfiguration prorPresentationConfiguration = (ProrPresentationConfiguration)theEObject;
-				T result = caseProrPresentationConfiguration(prorPresentationConfiguration);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION: {
-				ProrGeneralConfiguration prorGeneralConfiguration = (ProrGeneralConfiguration)theEObject;
-				T result = caseProrGeneralConfiguration(prorGeneralConfiguration);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.LABEL_CONFIGURATION: {
-				LabelConfiguration labelConfiguration = (LabelConfiguration)theEObject;
-				T result = caseLabelConfiguration(labelConfiguration);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			case ConfigurationPackage.UNIFIED_COLUMN: {
-				UnifiedColumn unifiedColumn = (UnifiedColumn)theEObject;
-				T result = caseUnifiedColumn(unifiedColumn);
-				if (result == null) result = caseColumn(unifiedColumn);
-				if (result == null) result = defaultCase(theEObject);
-				return result;
-			}
-			default: return defaultCase(theEObject);
-		}
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Pror Tool Extension</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>Pror Tool Extension</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseProrToolExtension(ProrToolExtension object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Pror Spec View Configuration</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>Pror Spec View Configuration</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseProrSpecViewConfiguration(ProrSpecViewConfiguration object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Column</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>Column</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseColumn(Column object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Pror Presentation Configurations</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>Pror Presentation Configurations</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseProrPresentationConfigurations(ProrPresentationConfigurations object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Pror Presentation Configuration</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>Pror Presentation Configuration</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseProrPresentationConfiguration(ProrPresentationConfiguration object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Pror General Configuration</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>Pror General Configuration</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseProrGeneralConfiguration(ProrGeneralConfiguration object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Label Configuration</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>Label Configuration</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseLabelConfiguration(LabelConfiguration object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>Unified Column</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>Unified Column</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-	 * @generated
-	 */
-	public T caseUnifiedColumn(UnifiedColumn object) {
-		return null;
-	}
-
-	/**
-	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
-	 * <!-- begin-user-doc -->
-	 * This implementation returns null;
-	 * returning a non-null result will terminate the switch, but this is the last case anyway.
-	 * <!-- end-user-doc -->
-	 * @param object the target of the switch.
-	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
-	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
-	 * @generated
-	 */
-	@Override
-	public T defaultCase(EObject object) {
-		return null;
-	}
-
-} //ConfigSwitch
+/**
+ */
+package org.eclipse.rmf.reqif10.pror.configuration.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.rmf.reqif10.pror.configuration.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage
+ * @generated
+ */
+public class ConfigurationSwitch<T> extends Switch<T> {
+	/**
+	 * The cached model package
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static ConfigurationPackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public ConfigurationSwitch() {
+		if (modelPackage == null) {
+			modelPackage = ConfigurationPackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @parameter ePackage the package in question.
+	 * @return whether this is a switch for the given package.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * 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 ConfigurationPackage.PROR_TOOL_EXTENSION: {
+				ProrToolExtension prorToolExtension = (ProrToolExtension)theEObject;
+				T result = caseProrToolExtension(prorToolExtension);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.PROR_SPEC_VIEW_CONFIGURATION: {
+				ProrSpecViewConfiguration prorSpecViewConfiguration = (ProrSpecViewConfiguration)theEObject;
+				T result = caseProrSpecViewConfiguration(prorSpecViewConfiguration);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.COLUMN: {
+				Column column = (Column)theEObject;
+				T result = caseColumn(column);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATIONS: {
+				ProrPresentationConfigurations prorPresentationConfigurations = (ProrPresentationConfigurations)theEObject;
+				T result = caseProrPresentationConfigurations(prorPresentationConfigurations);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.PROR_PRESENTATION_CONFIGURATION: {
+				ProrPresentationConfiguration prorPresentationConfiguration = (ProrPresentationConfiguration)theEObject;
+				T result = caseProrPresentationConfiguration(prorPresentationConfiguration);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.PROR_GENERAL_CONFIGURATION: {
+				ProrGeneralConfiguration prorGeneralConfiguration = (ProrGeneralConfiguration)theEObject;
+				T result = caseProrGeneralConfiguration(prorGeneralConfiguration);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.LABEL_CONFIGURATION: {
+				LabelConfiguration labelConfiguration = (LabelConfiguration)theEObject;
+				T result = caseLabelConfiguration(labelConfiguration);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			case ConfigurationPackage.UNIFIED_COLUMN: {
+				UnifiedColumn unifiedColumn = (UnifiedColumn)theEObject;
+				T result = caseUnifiedColumn(unifiedColumn);
+				if (result == null) result = caseColumn(unifiedColumn);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Pror Tool Extension</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>Pror Tool Extension</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseProrToolExtension(ProrToolExtension object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Pror Spec View Configuration</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>Pror Spec View Configuration</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseProrSpecViewConfiguration(ProrSpecViewConfiguration object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Column</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>Column</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseColumn(Column object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Pror Presentation Configurations</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>Pror Presentation Configurations</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseProrPresentationConfigurations(ProrPresentationConfigurations object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Pror Presentation Configuration</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>Pror Presentation Configuration</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseProrPresentationConfiguration(ProrPresentationConfiguration object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Pror General Configuration</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>Pror General Configuration</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseProrGeneralConfiguration(ProrGeneralConfiguration object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Label Configuration</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>Label Configuration</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseLabelConfiguration(LabelConfiguration object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>Unified Column</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>Unified Column</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseUnifiedColumn(UnifiedColumn object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+} //ConfigurationSwitch
diff --git a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationXMLProcessor.java b/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationXMLProcessor.java
deleted file mode 100644
index 9105fa9..0000000
--- a/org.eclipse.rmf.reqif10.pror/src/org/eclipse/rmf/reqif10/pror/configuration/util/ConfigurationXMLProcessor.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/**
- * <copyright>
- * </copyright>
- *
- * $Id$
- */
-package org.eclipse.rmf.reqif10.pror.configuration.util;
-
-import java.util.Map;
-
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.util.XMLProcessor;
-import org.eclipse.rmf.reqif10.pror.configuration.ConfigurationPackage;
-
-/**
- * This class contains helper methods to serialize and deserialize XML documents
- * <!-- begin-user-doc -->
- * <!-- end-user-doc -->
- * @generated
- */
-public class ConfigurationXMLProcessor extends XMLProcessor {
-
-	/**
-	 * Public constructor to instantiate the helper.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	public ConfigurationXMLProcessor() {
-		super((EPackage.Registry.INSTANCE));
-		ConfigurationPackage.eINSTANCE.eClass();
-	}
-	
-	/**
-	 * Register for "*" and "xml" file extensions the ConfigurationResourceFactoryImpl factory.
-	 * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
-	 * @generated
-	 */
-	@Override
-	protected Map<String, Resource.Factory> getRegistrations() {
-		if (registrations == null) {
-			super.getRegistrations();
-			registrations.put(XML_EXTENSION, new ConfigurationResourceFactoryImpl());
-			registrations.put(STAR_EXTENSION, new ConfigurationResourceFactoryImpl());
-		}
-		return registrations;
-	}
-
-} //ConfigurationXMLProcessor
diff --git a/org.eclipse.rmf.reqif10.xhtml/plugin.xml b/org.eclipse.rmf.reqif10.xhtml/plugin.xml
index 2386793..87fc135 100644
--- a/org.eclipse.rmf.reqif10.xhtml/plugin.xml
+++ b/org.eclipse.rmf.reqif10.xhtml/plugin.xml
@@ -23,12 +23,6 @@
             genModel="model/xhtml.genmodel"/>
    </extension>
 
-   <extension point="org.eclipse.emf.ecore.extension_parser">
-      <!-- @generated xhtml -->
-      <parser
-            type="xhtml"
-            class="org.eclipse.rmf.reqif10.xhtml.util.XhtmlResourceFactoryImpl"/>
-   </extension>
 
    <extension point="org.eclipse.emf.ecore.generated_package">
       <!-- @generated xhtml -->
diff --git a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesResourceFactoryImpl.java b/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesResourceFactoryImpl.java
deleted file mode 100644
index 4ac7143..0000000
--- a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesResourceFactoryImpl.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2013 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.reqif10.datatypes.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl;
-
-/**
- * <!-- begin-user-doc --> The <b>Resource Factory</b> associated with the package. <!-- end-user-doc -->
- * 
- * @see org.eclipse.rmf.reqif10.datatypes.util.DatatypesResourceImpl
- * @generated
- */
-public class DatatypesResourceFactoryImpl extends ResourceFactoryImpl {
-	/**
-	 * Creates an instance of the resource factory. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public DatatypesResourceFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * Creates an instance of the resource. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	@Override
-	public Resource createResource(URI uri) {
-		Resource result = new DatatypesResourceImpl(uri);
-		return result;
-	}
-
-} // DatatypesResourceFactoryImpl
diff --git a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesResourceImpl.java b/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesResourceImpl.java
deleted file mode 100644
index e99b0f1..0000000
--- a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesResourceImpl.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Copyright (c) 2013 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.reqif10.datatypes.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl;
-
-/**
- * <!-- begin-user-doc --> The <b>Resource </b> associated with the package. <!-- end-user-doc -->
- * 
- * @see org.eclipse.rmf.reqif10.datatypes.util.DatatypesResourceFactoryImpl
- * @generated
- */
-public class DatatypesResourceImpl extends XMLResourceImpl {
-	/**
-	 * Creates an instance of the resource. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @param uri
-	 *            the URI of the new resource.
-	 * @generated
-	 */
-	public DatatypesResourceImpl(URI uri) {
-		super(uri);
-	}
-
-} // DatatypesResourceImpl
diff --git a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesXMLProcessor.java b/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesXMLProcessor.java
deleted file mode 100644
index 09100be..0000000
--- a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/datatypes/util/DatatypesXMLProcessor.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Copyright (c) 2013 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.reqif10.datatypes.util;
-
-import java.util.Map;
-
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.util.XMLProcessor;
-import org.eclipse.rmf.reqif10.datatypes.DatatypesPackage;
-
-/**
- * This class contains helper methods to serialize and deserialize XML documents <!-- begin-user-doc --> <!--
- * end-user-doc -->
- * 
- * @generated
- */
-public class DatatypesXMLProcessor extends XMLProcessor {
-
-	/**
-	 * Public constructor to instantiate the helper. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public DatatypesXMLProcessor() {
-		super((EPackage.Registry.INSTANCE));
-		DatatypesPackage.eINSTANCE.eClass();
-	}
-
-	/**
-	 * Register for "*" and "xml" file extensions the DatatypesResourceFactoryImpl factory. <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	@Override
-	protected Map<String, Resource.Factory> getRegistrations() {
-		if (registrations == null) {
-			super.getRegistrations();
-			registrations.put(XML_EXTENSION, new DatatypesResourceFactoryImpl());
-			registrations.put(STAR_EXTENSION, new DatatypesResourceFactoryImpl());
-		}
-		return registrations;
-	}
-
-} // DatatypesXMLProcessor
diff --git a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlResourceFactoryImpl.java b/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlResourceFactoryImpl.java
deleted file mode 100644
index 343d4bf..0000000
--- a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlResourceFactoryImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Copyright (c) 2013 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.reqif10.xhtml.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl;
-import org.eclipse.emf.ecore.xmi.XMLResource;
-
-/**
- * <!-- begin-user-doc --> The <b>Resource Factory</b> associated with the package. <!-- end-user-doc -->
- * 
- * @see org.eclipse.rmf.reqif10.xhtml.util.XhtmlResourceImpl
- * @generated
- */
-public class XhtmlResourceFactoryImpl extends ResourceFactoryImpl {
-	/**
-	 * Creates an instance of the resource factory. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public XhtmlResourceFactoryImpl() {
-		super();
-	}
-
-	/**
-	 * Creates an instance of the resource. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	@Override
-	public Resource createResource(URI uri) {
-		XMLResource result = new XhtmlResourceImpl(uri);
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, Boolean.TRUE);
-
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_SCHEMA_LOCATION, Boolean.TRUE);
-
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-		result.getDefaultSaveOptions().put(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE, Boolean.TRUE);
-
-		result.getDefaultLoadOptions().put(XMLResource.OPTION_USE_LEXICAL_HANDLER, Boolean.TRUE);
-		return result;
-	}
-
-} // XhtmlResourceFactoryImpl
diff --git a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlResourceImpl.java b/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlResourceImpl.java
deleted file mode 100644
index a5fd8f4..0000000
--- a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlResourceImpl.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- * Copyright (c) 2013 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.reqif10.xhtml.util;
-
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl;
-
-/**
- * <!-- begin-user-doc --> The <b>Resource </b> associated with the package. <!-- end-user-doc -->
- * 
- * @see org.eclipse.rmf.reqif10.xhtml.util.XhtmlResourceFactoryImpl
- * @generated
- */
-public class XhtmlResourceImpl extends XMLResourceImpl {
-	/**
-	 * Creates an instance of the resource. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @param uri
-	 *            the URI of the new resource.
-	 * @generated
-	 */
-	public XhtmlResourceImpl(URI uri) {
-		super(uri);
-	}
-
-} // XhtmlResourceImpl
diff --git a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlXMLProcessor.java b/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlXMLProcessor.java
deleted file mode 100644
index 9af32b0..0000000
--- a/org.eclipse.rmf.reqif10.xhtml/src/org/eclipse/rmf/reqif10/xhtml/util/XhtmlXMLProcessor.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * Copyright (c) 2013 itemis AG and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- * 
- * Contributors:
- *     Mark Broerkens - initial API and implementation
- * 
- */
-package org.eclipse.rmf.reqif10.xhtml.util;
-
-import java.util.Map;
-
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.util.XMLProcessor;
-import org.eclipse.rmf.reqif10.xhtml.XhtmlPackage;
-
-/**
- * This class contains helper methods to serialize and deserialize XML documents <!-- begin-user-doc --> <!--
- * end-user-doc -->
- * 
- * @generated
- */
-public class XhtmlXMLProcessor extends XMLProcessor {
-
-	/**
-	 * Public constructor to instantiate the helper. <!-- begin-user-doc --> <!-- end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	public XhtmlXMLProcessor() {
-		super((EPackage.Registry.INSTANCE));
-		XhtmlPackage.eINSTANCE.eClass();
-	}
-
-	/**
-	 * Register for "*" and "xml" file extensions the XhtmlResourceFactoryImpl factory. <!-- begin-user-doc --> <!--
-	 * end-user-doc -->
-	 * 
-	 * @generated
-	 */
-	@Override
-	protected Map<String, Resource.Factory> getRegistrations() {
-		if (registrations == null) {
-			super.getRegistrations();
-			registrations.put(XML_EXTENSION, new XhtmlResourceFactoryImpl());
-			registrations.put(STAR_EXTENSION, new XhtmlResourceFactoryImpl());
-		}
-		return registrations;
-	}
-
-} // XhtmlXMLProcessor
