diff --git a/org.eclipse.osbp.ecview.extension.api.feature/feature.xml b/org.eclipse.osbp.ecview.extension.api.feature/feature.xml
index 5eb4e52..602a953 100644
--- a/org.eclipse.osbp.ecview.extension.api.feature/feature.xml
+++ b/org.eclipse.osbp.ecview.extension.api.feature/feature.xml
@@ -4,7 +4,7 @@
       label="%featureName"
       version="0.9.0.qualifier"
       provider-name="%providerName"
-	  plugin="org.eclipse.osbp.ecview.extension.api">
+	  plugin="org.eclipse.osbp.license">
 
    <description>
       %description
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java
index dd1fbe4..b3a44f3 100644
--- a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/IFocusingStrategy.java
@@ -15,9 +15,12 @@
  */
 package org.eclipse.osbp.ecview.extension.api;
 
+import org.eclipse.osbp.ecview.core.common.model.core.YView;
 import org.eclipse.osbp.ecview.core.common.services.IWidgetAssocationsService;
 import org.eclipse.osbp.runtime.common.keystroke.KeyStrokeDefinition;
 
+import com.vaadin.ui.UI;
+
 import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
 
 /**
@@ -55,5 +58,12 @@
 	 * @return the key stroke definition
 	 */
 	KeyStrokeDefinition getKeyStrokeDefinition();
-
+	
+	/**
+	 * Focus a field by id or the first focusable field if null.
+	 *
+	 * @param yView the y view
+	 * @param fieldId the field id
+	 */
+	void focusField(YView yView, String fieldId);
 }
diff --git a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java
index 6791afb..895cbf9 100644
--- a/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java
+++ b/org.eclipse.osbp.ecview.extension.api/src/org/eclipse/osbp/ecview/extension/api/ILayoutingStrategy.java
@@ -123,6 +123,9 @@
 	/** The Constant TAG__GROUP. */
 	public static final String TAG__GROUP = "group";
 
+	/** The Constant TAG__EXTRASTYLE. */
+	public static final String TAG__EXTRASTYLE = "extraStyle";
+	
 	/** The Constant TAG__BEAN. */
 	public static final String TAG__BEAN = "bean";
 	
@@ -135,6 +138,9 @@
 	/** The Constant TAG__UNIQUE. */
 	public static final String TAG__UNIQUE = "unique";
 
+	/** The Constant TAG__SAVEANDNEW. */
+	public static final String TAG__SAVEANDNEW = "saveAndNew";
+
 	/**
 	 * The Constant TAG__DTO. Suspects of this type define suspects for a whole
 	 * dto.
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/plugin.properties b/org.eclipse.osbp.ecview.extension.model.edit/plugin.properties
index 84dd696..0d052e6 100644
--- a/org.eclipse.osbp.ecview.extension.model.edit/plugin.properties
+++ b/org.eclipse.osbp.ecview.extension.model.edit/plugin.properties
@@ -201,3 +201,5 @@
 _UI_YStringToByteArrayConverter_type = YString To Byte Array Converter
 _UI_YTypedCompoundSuspect_onTab_feature = On Tab
 _UI_YColumnInfo_sourceType_feature = Source Type
+_UI_YSuspect_styleName_feature = Style Name
+_UI_YStrategyLayout_saveAndNew_feature = Save And New
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java
index 073de5d..4276cb6 100644
--- a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YStrategyLayoutItemProvider.java
@@ -78,6 +78,7 @@
 
 			addDefaultFocusingEnhancerIdPropertyDescriptor(object);
 			addNumberColumnsPropertyDescriptor(object);
+			addSaveAndNewPropertyDescriptor(object);
 		}
 		return itemPropertyDescriptors;
 	}
@@ -126,6 +127,28 @@
 	}
 
 	/**
+	 * This adds a property descriptor for the Save And New feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addSaveAndNewPropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YStrategyLayout_saveAndNew_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YStrategyLayout_saveAndNew_feature", "_UI_YStrategyLayout_type"),
+				 YECviewPackage.Literals.YSTRATEGY_LAYOUT__SAVE_AND_NEW,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.BOOLEAN_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
 	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
 	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
 	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
@@ -202,6 +225,7 @@
 		switch (notification.getFeatureID(YStrategyLayout.class)) {
 			case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
 			case YECviewPackage.YSTRATEGY_LAYOUT__NUMBER_COLUMNS:
+			case YECviewPackage.YSTRATEGY_LAYOUT__SAVE_AND_NEW:
 				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
 				return;
 			case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
diff --git a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java
index 259974a..5e76b8d 100644
--- a/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java
+++ b/org.eclipse.osbp.ecview.extension.model.edit/src/org/eclipse/osbp/ecview/extension/model/provider/YSuspectItemProvider.java
@@ -113,6 +113,7 @@
 			addAssocNewiatedElementsPropertyDescriptor(object);
 			addLabelPropertyDescriptor(object);
 			addGroupNamePropertyDescriptor(object);
+			addStyleNamePropertyDescriptor(object);
 		}
 		return itemPropertyDescriptors;
 	}
@@ -347,6 +348,28 @@
 	}
 
 	/**
+	 * This adds a property descriptor for the Style Name feature.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected void addStyleNamePropertyDescriptor(Object object) {
+		itemPropertyDescriptors.add
+			(createItemPropertyDescriptor
+				(((ComposeableAdapterFactory)adapterFactory).getRootAdapterFactory(),
+				 getResourceLocator(),
+				 getString("_UI_YSuspect_styleName_feature"),
+				 getString("_UI_PropertyDescriptor_description", "_UI_YSuspect_styleName_feature", "_UI_YSuspect_type"),
+				 YECviewPackage.Literals.YSUSPECT__STYLE_NAME,
+				 true,
+				 false,
+				 false,
+				 ItemPropertyDescriptor.GENERIC_VALUE_IMAGE,
+				 null,
+				 null));
+	}
+
+	/**
 	 * This specifies how to implement {@link #getChildren} and is used to deduce an appropriate feature for an
 	 * {@link org.eclipse.emf.edit.command.AddCommand}, {@link org.eclipse.emf.edit.command.RemoveCommand} or
 	 * {@link org.eclipse.emf.edit.command.MoveCommand} in {@link #createCommand}.
@@ -431,6 +454,7 @@
 			case YECviewPackage.YSUSPECT__IMAGE_I1_8N_KEY:
 			case YECviewPackage.YSUSPECT__LABEL:
 			case YECviewPackage.YSUSPECT__GROUP_NAME:
+			case YECviewPackage.YSUSPECT__STYLE_NAME:
 				fireNotifyChanged(new ViewerNotification(notification, notification.getNotifier(), false, true));
 				return;
 			case YECviewPackage.YSUSPECT__PROPERTIES:
diff --git a/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore b/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore
index 0da26ef..2f697a9 100644
--- a/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore
+++ b/org.eclipse.osbp.ecview.extension.model/model/ecview.ecore
@@ -13,6 +13,7 @@
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="defaultFocusingEnhancerId"
         eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="numberColumns" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="saveAndNew" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="YLayoutingStrategy" eSuperTypes="../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YElement">
     <eOperations name="getView" eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/core.ecore#//YView"/>
@@ -58,6 +59,7 @@
         eType="ecore:EClass ../../org.eclipse.osbp.ecview.core.common.model/model/binding.ecore#//YValueBindingEndpoint"
         containment="true"/>
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="groupName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="styleName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="YTypedSuspect" eSuperTypes="#//YSuspect">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="typeQualifiedName" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
diff --git a/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel b/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel
index 05bac38..d2852be 100644
--- a/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel
+++ b/org.eclipse.osbp.ecview.extension.model/model/ecview.genmodel
@@ -17,6 +17,7 @@
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YStrategyLayout/layoutingInfo"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YStrategyLayout/defaultFocusingEnhancerId"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YStrategyLayout/numberColumns"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YStrategyLayout/saveAndNew"/>
     </genClasses>
     <genClasses ecoreClass="ecview.ecore#//YLayoutingStrategy">
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YLayoutingStrategy/trigger"/>
@@ -45,6 +46,7 @@
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YSuspect/label"/>
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference ecview.ecore#//YSuspect/containerValueBindingEndpoint"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YSuspect/groupName"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YSuspect/styleName"/>
     </genClasses>
     <genClasses ecoreClass="ecview.ecore#//YTypedSuspect">
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute ecview.ecore#//YTypedSuspect/typeQualifiedName"/>
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java
index 9d10141..30c10cc 100644
--- a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YECviewPackage.java
@@ -306,13 +306,22 @@
 	int YSTRATEGY_LAYOUT__NUMBER_COLUMNS = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 5;
 
 	/**
+	 * The feature id for the '<em><b>Save And New</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSTRATEGY_LAYOUT__SAVE_AND_NEW = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 6;
+
+	/**
 	 * The number of structural features of the '<em>YStrategy Layout</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 * @ordered
 	 */
-	int YSTRATEGY_LAYOUT_FEATURE_COUNT = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 6;
+	int YSTRATEGY_LAYOUT_FEATURE_COUNT = CoreModelPackage.YEMBEDDABLE_FEATURE_COUNT + 7;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl <em>YLayouting Strategy</em>}' class.
@@ -825,13 +834,22 @@
 	int YSUSPECT__GROUP_NAME = CoreModelPackage.YELEMENT_FEATURE_COUNT + 11;
 
 	/**
+	 * The feature id for the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUSPECT__STYLE_NAME = CoreModelPackage.YELEMENT_FEATURE_COUNT + 12;
+
+	/**
 	 * The number of structural features of the '<em>YSuspect</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 * @ordered
 	 */
-	int YSUSPECT_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 12;
+	int YSUSPECT_FEATURE_COUNT = CoreModelPackage.YELEMENT_FEATURE_COUNT + 13;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl <em>YLayouting Info</em>}' class.
@@ -1018,6 +1036,15 @@
 	int YTYPED_SUSPECT__GROUP_NAME = YSUSPECT__GROUP_NAME;
 
 	/**
+	 * The feature id for the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_SUSPECT__STYLE_NAME = YSUSPECT__STYLE_NAME;
+
+	/**
 	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1199,6 +1226,15 @@
 	int YTYPED_COMPOUND_SUSPECT__GROUP_NAME = YTYPED_SUSPECT__GROUP_NAME;
 
 	/**
+	 * The feature id for the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YTYPED_COMPOUND_SUSPECT__STYLE_NAME = YTYPED_SUSPECT__STYLE_NAME;
+
+	/**
 	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1389,6 +1425,15 @@
 	int YSUB_TYPE_BASE_SUSPECT__GROUP_NAME = YTYPED_COMPOUND_SUSPECT__GROUP_NAME;
 
 	/**
+	 * The feature id for the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_BASE_SUSPECT__STYLE_NAME = YTYPED_COMPOUND_SUSPECT__STYLE_NAME;
+
+	/**
 	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1579,6 +1624,15 @@
 	int YSUB_TYPE_SUSPECT__GROUP_NAME = YTYPED_COMPOUND_SUSPECT__GROUP_NAME;
 
 	/**
+	 * The feature id for the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YSUB_TYPE_SUSPECT__STYLE_NAME = YTYPED_COMPOUND_SUSPECT__STYLE_NAME;
+
+	/**
 	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -3601,6 +3655,15 @@
 	int YCOLLECTION_SUSPECT__GROUP_NAME = YTYPED_SUSPECT__GROUP_NAME;
 
 	/**
+	 * The feature id for the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCOLLECTION_SUSPECT__STYLE_NAME = YTYPED_SUSPECT__STYLE_NAME;
+
+	/**
 	 * The feature id for the '<em><b>Type Qualified Name</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -3954,6 +4017,15 @@
 	int YCONTENT_SENSITIVE_LAYOUT__NUMBER_COLUMNS = CoreModelPackage.YLAYOUT__NUMBER_COLUMNS;
 
 	/**
+	 * The feature id for the '<em><b>Save And New</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int YCONTENT_SENSITIVE_LAYOUT__SAVE_AND_NEW = CoreModelPackage.YLAYOUT__SAVE_AND_NEW;
+
+	/**
 	 * The feature id for the '<em><b>Spacing</b></em>' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -6035,6 +6107,17 @@
 	EAttribute getYStrategyLayout_NumberColumns();
 
 	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#isSaveAndNew <em>Save And New</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Save And New</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YStrategyLayout#isSaveAndNew()
+	 * @see #getYStrategyLayout()
+	 * @generated
+	 */
+	EAttribute getYStrategyLayout_SaveAndNew();
+
+	/**
 	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy <em>YLayouting Strategy</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -6260,6 +6343,17 @@
 	EAttribute getYSuspect_GroupName();
 
 	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getStyleName <em>Style Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Style Name</em>'.
+	 * @see org.eclipse.osbp.ecview.extension.model.YSuspect#getStyleName()
+	 * @see #getYSuspect()
+	 * @generated
+	 */
+	EAttribute getYSuspect_StyleName();
+
+	/**
 	 * Returns the meta object for class '{@link org.eclipse.osbp.ecview.extension.model.YLayoutingInfo <em>YLayouting Info</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -7387,6 +7481,14 @@
 		EAttribute YSTRATEGY_LAYOUT__NUMBER_COLUMNS = eINSTANCE.getYStrategyLayout_NumberColumns();
 
 		/**
+		 * The meta object literal for the '<em><b>Save And New</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSTRATEGY_LAYOUT__SAVE_AND_NEW = eINSTANCE.getYStrategyLayout_SaveAndNew();
+
+		/**
 		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingStrategyImpl <em>YLayouting Strategy</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
@@ -7567,6 +7669,14 @@
 		EAttribute YSUSPECT__GROUP_NAME = eINSTANCE.getYSuspect_GroupName();
 
 		/**
+		 * The meta object literal for the '<em><b>Style Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute YSUSPECT__STYLE_NAME = eINSTANCE.getYSuspect_StyleName();
+
+		/**
 		 * The meta object literal for the '{@link org.eclipse.osbp.ecview.extension.model.impl.YLayoutingInfoImpl <em>YLayouting Info</em>}' class.
 		 * <!-- begin-user-doc -->
 		 * <!-- end-user-doc -->
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java
index 2f6c525..2747ebf 100644
--- a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YStrategyLayout.java
@@ -33,6 +33,7 @@
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getLayoutingInfo <em>Layouting Info</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getDefaultFocusingEnhancerId <em>Default Focusing Enhancer Id</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#getNumberColumns <em>Number Columns</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#isSaveAndNew <em>Save And New</em>}</li>
  * </ul>
  *
  * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout()
@@ -185,6 +186,32 @@
 	void setNumberColumns(int value);
 
 	/**
+	 * Returns the value of the '<em><b>Save And New</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Save And New</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Save And New</em>' attribute.
+	 * @see #setSaveAndNew(boolean)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYStrategyLayout_SaveAndNew()
+	 * @model
+	 * @generated
+	 */
+	boolean isSaveAndNew();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YStrategyLayout#isSaveAndNew <em>Save And New</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Save And New</em>' attribute.
+	 * @see #isSaveAndNew()
+	 * @generated
+	 */
+	void setSaveAndNew(boolean value);
+
+	/**
 	 * Uses the suspect info form layouting info to find the proper suspectinfo
 	 * for the given embeddable.
 	 *
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java
index 9c70143..ec29687 100644
--- a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/YSuspect.java
@@ -45,6 +45,7 @@
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getLabel <em>Label</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getContainerValueBindingEndpoint <em>Container Value Binding Endpoint</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getGroupName <em>Group Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getStyleName <em>Style Name</em>}</li>
  * </ul>
  *
  * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect()
@@ -271,6 +272,32 @@
 	void setGroupName(String value);
 
 	/**
+	 * Returns the value of the '<em><b>Style Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Style Name</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Style Name</em>' attribute.
+	 * @see #setStyleName(String)
+	 * @see org.eclipse.osbp.ecview.extension.model.YECviewPackage#getYSuspect_StyleName()
+	 * @model
+	 * @generated
+	 */
+	String getStyleName();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.osbp.ecview.extension.model.YSuspect#getStyleName <em>Style Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Style Name</em>' attribute.
+	 * @see #getStyleName()
+	 * @generated
+	 */
+	void setStyleName(String value);
+
+	/**
 	 * Gets the view.
 	 *
 	 * @return the view
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java
index d82347a..5d87dbc 100644
--- a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YECviewPackageImpl.java
@@ -422,6 +422,15 @@
 	}
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYStrategyLayout_SaveAndNew() {
+		return (EAttribute)yStrategyLayoutEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
 	 *
 	 * @return the y layouting strategy
@@ -630,6 +639,15 @@
 	}
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getYSuspect_StyleName() {
+		return (EAttribute)ySuspectEClass.getEStructuralFeatures().get(10);
+	}
+
+	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
 	 *
 	 * @return the y layouting info
@@ -1583,6 +1601,7 @@
 		createEReference(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__LAYOUTING_INFO);
 		createEAttribute(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID);
 		createEAttribute(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__NUMBER_COLUMNS);
+		createEAttribute(yStrategyLayoutEClass, YSTRATEGY_LAYOUT__SAVE_AND_NEW);
 
 		yLayoutingStrategyEClass = createEClass(YLAYOUTING_STRATEGY);
 		createEAttribute(yLayoutingStrategyEClass, YLAYOUTING_STRATEGY__TRIGGER);
@@ -1610,6 +1629,7 @@
 		createEAttribute(ySuspectEClass, YSUSPECT__LABEL);
 		createEReference(ySuspectEClass, YSUSPECT__CONTAINER_VALUE_BINDING_ENDPOINT);
 		createEAttribute(ySuspectEClass, YSUSPECT__GROUP_NAME);
+		createEAttribute(ySuspectEClass, YSUSPECT__STYLE_NAME);
 
 		yTypedSuspectEClass = createEClass(YTYPED_SUSPECT);
 		createEAttribute(yTypedSuspectEClass, YTYPED_SUSPECT__TYPE_QUALIFIED_NAME);
@@ -1827,6 +1847,7 @@
 		initEReference(getYStrategyLayout_LayoutingInfo(), this.getYLayoutingInfo(), null, "layoutingInfo", null, 0, 1, YStrategyLayout.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getYStrategyLayout_DefaultFocusingEnhancerId(), ecorePackage.getEString(), "defaultFocusingEnhancerId", null, 0, 1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getYStrategyLayout_NumberColumns(), ecorePackage.getEInt(), "numberColumns", null, 0, 1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYStrategyLayout_SaveAndNew(), ecorePackage.getEBoolean(), "saveAndNew", null, 0, 1, YStrategyLayout.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
 		initEClass(yLayoutingStrategyEClass, YLayoutingStrategy.class, "YLayoutingStrategy", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
 		initEAttribute(getYLayoutingStrategy_Trigger(), ecorePackage.getEJavaObject(), "trigger", null, 0, 1, YLayoutingStrategy.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
@@ -1858,6 +1879,7 @@
 		initEAttribute(getYSuspect_Label(), ecorePackage.getEString(), "label", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEReference(getYSuspect_ContainerValueBindingEndpoint(), theBindingPackage.getYValueBindingEndpoint(), null, "containerValueBindingEndpoint", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getYSuspect_GroupName(), ecorePackage.getEString(), "groupName", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getYSuspect_StyleName(), ecorePackage.getEString(), "styleName", null, 0, 1, YSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
 		initEClass(yTypedSuspectEClass, YTypedSuspect.class, "YTypedSuspect", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
 		initEAttribute(getYTypedSuspect_TypeQualifiedName(), ecorePackage.getEString(), "typeQualifiedName", null, 0, 1, YTypedSuspect.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java
index ba7b3cd..42be3da 100644
--- a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YStrategyLayoutImpl.java
@@ -49,6 +49,7 @@
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getLayoutingInfo <em>Layouting Info</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getDefaultFocusingEnhancerId <em>Default Focusing Enhancer Id</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#getNumberColumns <em>Number Columns</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YStrategyLayoutImpl#isSaveAndNew <em>Save And New</em>}</li>
  * </ul>
  *
  * @generated
@@ -143,6 +144,26 @@
 	protected int numberColumns = NUMBER_COLUMNS_EDEFAULT;
 
 	/**
+	 * The default value of the '{@link #isSaveAndNew() <em>Save And New</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSaveAndNew()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean SAVE_AND_NEW_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isSaveAndNew() <em>Save And New</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSaveAndNew()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean saveAndNew = SAVE_AND_NEW_EDEFAULT;
+
+	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
 	 *
 	 * @generated
@@ -345,6 +366,27 @@
 	}
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public boolean isSaveAndNew() {
+		return saveAndNew;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setSaveAndNew(boolean newSaveAndNew) {
+		boolean oldSaveAndNew = saveAndNew;
+		saveAndNew = newSaveAndNew;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSTRATEGY_LAYOUT__SAVE_AND_NEW, oldSaveAndNew, saveAndNew));
+	}
+
+	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
 	 *
 	 * @param otherEnd
@@ -398,6 +440,8 @@
 				return getDefaultFocusingEnhancerId();
 			case YECviewPackage.YSTRATEGY_LAYOUT__NUMBER_COLUMNS:
 				return getNumberColumns();
+			case YECviewPackage.YSTRATEGY_LAYOUT__SAVE_AND_NEW:
+				return isSaveAndNew();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -435,6 +479,9 @@
 			case YECviewPackage.YSTRATEGY_LAYOUT__NUMBER_COLUMNS:
 				setNumberColumns((Integer)newValue);
 				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__SAVE_AND_NEW:
+				setSaveAndNew((Boolean)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -467,6 +514,9 @@
 			case YECviewPackage.YSTRATEGY_LAYOUT__NUMBER_COLUMNS:
 				setNumberColumns(NUMBER_COLUMNS_EDEFAULT);
 				return;
+			case YECviewPackage.YSTRATEGY_LAYOUT__SAVE_AND_NEW:
+				setSaveAndNew(SAVE_AND_NEW_EDEFAULT);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -494,6 +544,8 @@
 				return DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT == null ? defaultFocusingEnhancerId != null : !DEFAULT_FOCUSING_ENHANCER_ID_EDEFAULT.equals(defaultFocusingEnhancerId);
 			case YECviewPackage.YSTRATEGY_LAYOUT__NUMBER_COLUMNS:
 				return numberColumns != NUMBER_COLUMNS_EDEFAULT;
+			case YECviewPackage.YSTRATEGY_LAYOUT__SAVE_AND_NEW:
+				return saveAndNew != SAVE_AND_NEW_EDEFAULT;
 		}
 		return super.eIsSet(featureID);
 	}
@@ -513,6 +565,8 @@
 		result.append(defaultFocusingEnhancerId);
 		result.append(", numberColumns: ");
 		result.append(numberColumns);
+		result.append(", saveAndNew: ");
+		result.append(saveAndNew);
 		result.append(')');
 		return result.toString();
 	}
diff --git a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java
index 6adf292..f416ee3 100644
--- a/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java
+++ b/org.eclipse.osbp.ecview.extension.model/src/org/eclipse/osbp/ecview/extension/model/impl/YSuspectImpl.java
@@ -70,6 +70,7 @@
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getLabel <em>Label</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getContainerValueBindingEndpoint <em>Container Value Binding Endpoint</em>}</li>
  *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getGroupName <em>Group Name</em>}</li>
+ *   <li>{@link org.eclipse.osbp.ecview.extension.model.impl.YSuspectImpl#getStyleName <em>Style Name</em>}</li>
  * </ul>
  *
  * @generated
@@ -324,6 +325,26 @@
 	protected String groupName = GROUP_NAME_EDEFAULT;
 
 	/**
+	 * The default value of the '{@link #getStyleName() <em>Style Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getStyleName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String STYLE_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getStyleName() <em>Style Name</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getStyleName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String styleName = STYLE_NAME_EDEFAULT;
+
+	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
 	 *
 	 * @generated
@@ -687,6 +708,27 @@
 	}
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public String getStyleName() {
+		return styleName;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setStyleName(String newStyleName) {
+		String oldStyleName = styleName;
+		styleName = newStyleName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, YECviewPackage.YSUSPECT__STYLE_NAME, oldStyleName, styleName));
+	}
+
+	/**
 	 * <!-- begin-user-doc --> <!-- end-user-doc -->.
 	 *
 	 * @param otherEnd
@@ -765,6 +807,8 @@
 				return getContainerValueBindingEndpoint();
 			case YECviewPackage.YSUSPECT__GROUP_NAME:
 				return getGroupName();
+			case YECviewPackage.YSUSPECT__STYLE_NAME:
+				return getStyleName();
 		}
 		return super.eGet(featureID, resolve, coreType);
 	}
@@ -836,6 +880,9 @@
 			case YECviewPackage.YSUSPECT__GROUP_NAME:
 				setGroupName((String)newValue);
 				return;
+			case YECviewPackage.YSUSPECT__STYLE_NAME:
+				setStyleName((String)newValue);
+				return;
 		}
 		super.eSet(featureID, newValue);
 	}
@@ -898,6 +945,9 @@
 			case YECviewPackage.YSUSPECT__GROUP_NAME:
 				setGroupName(GROUP_NAME_EDEFAULT);
 				return;
+			case YECviewPackage.YSUSPECT__STYLE_NAME:
+				setStyleName(STYLE_NAME_EDEFAULT);
+				return;
 		}
 		super.eUnset(featureID);
 	}
@@ -945,6 +995,8 @@
 				return containerValueBindingEndpoint != null;
 			case YECviewPackage.YSUSPECT__GROUP_NAME:
 				return GROUP_NAME_EDEFAULT == null ? groupName != null : !GROUP_NAME_EDEFAULT.equals(groupName);
+			case YECviewPackage.YSUSPECT__STYLE_NAME:
+				return STYLE_NAME_EDEFAULT == null ? styleName != null : !STYLE_NAME_EDEFAULT.equals(styleName);
 		}
 		return super.eIsSet(featureID);
 	}
@@ -1022,6 +1074,8 @@
 		result.append(label);
 		result.append(", groupName: ");
 		result.append(groupName);
+		result.append(", styleName: ");
+		result.append(styleName);
 		result.append(')');
 		return result.toString();
 	}
