diff --git a/bundles/org.eclipse.e4.ui.model.workbench/META-INF/MANIFEST.MF b/bundles/org.eclipse.e4.ui.model.workbench/META-INF/MANIFEST.MF
index e41937f..12ef692 100644
--- a/bundles/org.eclipse.e4.ui.model.workbench/META-INF/MANIFEST.MF
+++ b/bundles/org.eclipse.e4.ui.model.workbench/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.e4.ui.model.workbench;singleton:=true
-Bundle-Version: 2.1.1000.qualifier
+Bundle-Version: 2.2.0.qualifier
 Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
diff --git a/bundles/org.eclipse.e4.ui.model.workbench/model/UIElements.ecore b/bundles/org.eclipse.e4.ui.model.workbench/model/UIElements.ecore
index 523ed3b..90176c2 100644
--- a/bundles/org.eclipse.e4.ui.model.workbench/model/UIElements.ecore
+++ b/bundles/org.eclipse.e4.ui.model.workbench/model/UIElements.ecore
@@ -995,25 +995,25 @@
           </eAnnotations>
         </eStructuralFeatures>
         <eStructuralFeatures xsi:type="ecore:EAttribute" name="x" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
-            defaultValueLiteral="-2147483648">
+            defaultValueLiteral="-2147483648" unsettable="true">
           <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
             <details key="documentation" value="&lt;p>&#xD;&#xA;The 'X' position of this window&#xD;&#xA;&lt;/p>"/>
           </eAnnotations>
         </eStructuralFeatures>
         <eStructuralFeatures xsi:type="ecore:EAttribute" name="y" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
-            defaultValueLiteral="-2147483648">
+            defaultValueLiteral="-2147483648" unsettable="true">
           <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
             <details key="documentation" value="&lt;p>&#xD;&#xA;The 'Y' position of this window&#xD;&#xA;&lt;/p>"/>
           </eAnnotations>
         </eStructuralFeatures>
         <eStructuralFeatures xsi:type="ecore:EAttribute" name="width" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
-            defaultValueLiteral="-1">
+            defaultValueLiteral="-1" unsettable="true">
           <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
             <details key="documentation" value="&lt;p>&#xD;&#xA;The width of this window&#xD;&#xA;&lt;/p>"/>
           </eAnnotations>
         </eStructuralFeatures>
         <eStructuralFeatures xsi:type="ecore:EAttribute" name="height" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
-            defaultValueLiteral="-1">
+            defaultValueLiteral="-1" unsettable="true">
           <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
             <details key="documentation" value="&lt;p>&#xD;&#xA;The heigfht of this window&#xD;&#xA;&lt;/p>"/>
           </eAnnotations>
diff --git a/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/MWindow.java b/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/MWindow.java
index ece86e6..2b4f3a5 100644
--- a/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/MWindow.java
+++ b/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/MWindow.java
@@ -54,7 +54,7 @@
  * @generated
  */
 public interface MWindow
-		extends MElementContainer<MWindowElement>, MUILabel, MContext, MHandlerContainer, MBindings, MSnippetContainer {
+extends MElementContainer<MWindowElement>, MUILabel, MContext, MHandlerContainer, MBindings, MSnippetContainer {
 	/**
 	 * Returns the value of the '<em><b>Main Menu</b></em>' containment reference.
 	 * <!-- begin-user-doc -->
@@ -92,8 +92,10 @@
 	 * </p>
 	 * <!-- end-model-doc -->
 	 * @return the value of the '<em>X</em>' attribute.
+	 * @see #isSetX()
+	 * @see #unsetX()
 	 * @see #setX(int)
-	 * @model default="-2147483648"
+	 * @model default="-2147483648" unsettable="true"
 	 * @generated
 	 */
 	int getX();
@@ -103,12 +105,39 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @param value the new value of the '<em>X</em>' attribute.
+	 * @see #isSetX()
+	 * @see #unsetX()
 	 * @see #getX()
 	 * @generated
 	 */
 	void setX(int value);
 
 	/**
+	 * Unsets the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getX <em>X</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @see #isSetX()
+	 * @see #getX()
+	 * @see #setX(int)
+	 * @generated
+	 */
+	void unsetX();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getX <em>X</em>}' attribute is set.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>X</em>' attribute is set.
+	 * @see #unsetX()
+	 * @see #getX()
+	 * @see #setX(int)
+	 * @generated
+	 */
+	boolean isSetX();
+
+	/**
 	 * Returns the value of the '<em><b>Y</b></em>' attribute.
 	 * The default value is <code>"-2147483648"</code>.
 	 * <!-- begin-user-doc -->
@@ -119,8 +148,10 @@
 	 * </p>
 	 * <!-- end-model-doc -->
 	 * @return the value of the '<em>Y</em>' attribute.
+	 * @see #isSetY()
+	 * @see #unsetY()
 	 * @see #setY(int)
-	 * @model default="-2147483648"
+	 * @model default="-2147483648" unsettable="true"
 	 * @generated
 	 */
 	int getY();
@@ -130,12 +161,39 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @param value the new value of the '<em>Y</em>' attribute.
+	 * @see #isSetY()
+	 * @see #unsetY()
 	 * @see #getY()
 	 * @generated
 	 */
 	void setY(int value);
 
 	/**
+	 * Unsets the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getY <em>Y</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @see #isSetY()
+	 * @see #getY()
+	 * @see #setY(int)
+	 * @generated
+	 */
+	void unsetY();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getY <em>Y</em>}' attribute is set.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Y</em>' attribute is set.
+	 * @see #unsetY()
+	 * @see #getY()
+	 * @see #setY(int)
+	 * @generated
+	 */
+	boolean isSetY();
+
+	/**
 	 * Returns the value of the '<em><b>Width</b></em>' attribute.
 	 * The default value is <code>"-1"</code>.
 	 * <!-- begin-user-doc -->
@@ -146,8 +204,10 @@
 	 * </p>
 	 * <!-- end-model-doc -->
 	 * @return the value of the '<em>Width</em>' attribute.
+	 * @see #isSetWidth()
+	 * @see #unsetWidth()
 	 * @see #setWidth(int)
-	 * @model default="-1"
+	 * @model default="-1" unsettable="true"
 	 * @generated
 	 */
 	int getWidth();
@@ -157,12 +217,39 @@
 	 * <!-- 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.e4.ui.model.application.ui.basic.MWindow#getWidth <em>Width</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @see #isSetWidth()
+	 * @see #getWidth()
+	 * @see #setWidth(int)
+	 * @generated
+	 */
+	void unsetWidth();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getWidth <em>Width</em>}' attribute is set.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- 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();
+
+	/**
 	 * Returns the value of the '<em><b>Height</b></em>' attribute.
 	 * The default value is <code>"-1"</code>.
 	 * <!-- begin-user-doc -->
@@ -173,8 +260,10 @@
 	 * </p>
 	 * <!-- end-model-doc -->
 	 * @return the value of the '<em>Height</em>' attribute.
+	 * @see #isSetHeight()
+	 * @see #unsetHeight()
 	 * @see #setHeight(int)
-	 * @model default="-1"
+	 * @model default="-1" unsettable="true"
 	 * @generated
 	 */
 	int getHeight();
@@ -184,12 +273,39 @@
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @param value the new value of the '<em>Height</em>' attribute.
+	 * @see #isSetHeight()
+	 * @see #unsetHeight()
 	 * @see #getHeight()
 	 * @generated
 	 */
 	void setHeight(int value);
 
 	/**
+	 * Unsets the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getHeight <em>Height</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @see #isSetHeight()
+	 * @see #getHeight()
+	 * @see #setHeight(int)
+	 * @generated
+	 */
+	void unsetHeight();
+
+	/**
+	 * Returns whether the value of the '{@link org.eclipse.e4.ui.model.application.ui.basic.MWindow#getHeight <em>Height</em>}' attribute is set.
+	 * <!-- begin-user-doc -->
+	 * @since 2.2
+	 * <!-- end-user-doc -->
+	 * @return whether the value of the '<em>Height</em>' attribute is set.
+	 * @see #unsetHeight()
+	 * @see #getHeight()
+	 * @see #setHeight(int)
+	 * @generated
+	 */
+	boolean isSetHeight();
+
+	/**
 	 * Returns the value of the '<em><b>Windows</b></em>' containment reference list.
 	 * The list contents are of type {@link org.eclipse.e4.ui.model.application.ui.basic.MWindow}.
 	 * <!-- begin-user-doc -->
diff --git a/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/BasicPackageImpl.java b/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/BasicPackageImpl.java
index ebdb9f6..6807bc3 100644
--- a/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/BasicPackageImpl.java
+++ b/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/BasicPackageImpl.java
@@ -3986,13 +3986,13 @@
 				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
 				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getWindow_X(), ecorePackage.getEInt(), "x", "-2147483648", 0, 1, MWindow.class, !IS_TRANSIENT, //$NON-NLS-1$//$NON-NLS-2$
-				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+				!IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getWindow_Y(), ecorePackage.getEInt(), "y", "-2147483648", 0, 1, MWindow.class, !IS_TRANSIENT, //$NON-NLS-1$//$NON-NLS-2$
-				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+				!IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getWindow_Width(), ecorePackage.getEInt(), "width", "-1", 0, 1, MWindow.class, !IS_TRANSIENT, //$NON-NLS-1$//$NON-NLS-2$
-				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+				!IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getWindow_Height(), ecorePackage.getEInt(), "height", "-1", 0, 1, MWindow.class, !IS_TRANSIENT, //$NON-NLS-1$//$NON-NLS-2$
-				!IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+				!IS_VOLATILE, IS_CHANGEABLE, IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEReference(getWindow_Windows(), this.getWindow(), null, "windows", null, 0, -1, MWindow.class, //$NON-NLS-1$
 				!IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE,
 				IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
diff --git a/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/WindowImpl.java b/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/WindowImpl.java
index 54fe56d..e10695f 100644
--- a/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/WindowImpl.java
+++ b/bundles/org.eclipse.e4.ui.model.workbench/src/org/eclipse/e4/ui/model/application/ui/basic/impl/WindowImpl.java
@@ -270,6 +270,15 @@
 	protected int x = X_EDEFAULT;
 
 	/**
+	 * This is true if the X attribute has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean xESet;
+
+	/**
 	 * The default value of the '{@link #getY() <em>Y</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -290,6 +299,15 @@
 	protected int y = Y_EDEFAULT;
 
 	/**
+	 * This is true if the Y attribute has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean yESet;
+
+	/**
 	 * The default value of the '{@link #getWidth() <em>Width</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -310,6 +328,15 @@
 	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;
+
+	/**
 	 * The default value of the '{@link #getHeight() <em>Height</em>}' attribute.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -330,6 +357,15 @@
 	protected int height = HEIGHT_EDEFAULT;
 
 	/**
+	 * This is true if the Height attribute has been set.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean heightESet;
+
+	/**
 	 * The cached value of the '{@link #getWindows() <em>Windows</em>}' containment reference list.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -661,8 +697,36 @@
 	public void setX(int newX) {
 		int oldX = x;
 		x = newX;
+		boolean oldXESet = xESet;
+		xESet = true;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__X, oldX, x));
+			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__X, oldX, x, !oldXESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void unsetX() {
+		int oldX = x;
+		boolean oldXESet = xESet;
+		x = X_EDEFAULT;
+		xESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, BasicPackageImpl.WINDOW__X, oldX, X_EDEFAULT,
+					oldXESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isSetX() {
+		return xESet;
 	}
 
 	/**
@@ -684,8 +748,36 @@
 	public void setY(int newY) {
 		int oldY = y;
 		y = newY;
+		boolean oldYESet = yESet;
+		yESet = true;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__Y, oldY, y));
+			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__Y, oldY, y, !oldYESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void unsetY() {
+		int oldY = y;
+		boolean oldYESet = yESet;
+		y = Y_EDEFAULT;
+		yESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, BasicPackageImpl.WINDOW__Y, oldY, Y_EDEFAULT,
+					oldYESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isSetY() {
+		return yESet;
 	}
 
 	/**
@@ -707,8 +799,37 @@
 	public void setWidth(int newWidth) {
 		int oldWidth = width;
 		width = newWidth;
+		boolean oldWidthESet = widthESet;
+		widthESet = true;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__WIDTH, oldWidth, width));
+			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__WIDTH, oldWidth, width,
+					!oldWidthESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void unsetWidth() {
+		int oldWidth = width;
+		boolean oldWidthESet = widthESet;
+		width = WIDTH_EDEFAULT;
+		widthESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, BasicPackageImpl.WINDOW__WIDTH, oldWidth,
+					WIDTH_EDEFAULT, oldWidthESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isSetWidth() {
+		return widthESet;
 	}
 
 	/**
@@ -730,8 +851,37 @@
 	public void setHeight(int newHeight) {
 		int oldHeight = height;
 		height = newHeight;
+		boolean oldHeightESet = heightESet;
+		heightESet = true;
 		if (eNotificationRequired())
-			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__HEIGHT, oldHeight, height));
+			eNotify(new ENotificationImpl(this, Notification.SET, BasicPackageImpl.WINDOW__HEIGHT, oldHeight, height,
+					!oldHeightESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void unsetHeight() {
+		int oldHeight = height;
+		boolean oldHeightESet = heightESet;
+		height = HEIGHT_EDEFAULT;
+		heightESet = false;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.UNSET, BasicPackageImpl.WINDOW__HEIGHT, oldHeight,
+					HEIGHT_EDEFAULT, oldHeightESet));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isSetHeight() {
+		return heightESet;
 	}
 
 	/**
@@ -965,16 +1115,16 @@
 			setMainMenu((MMenu) null);
 			return;
 		case BasicPackageImpl.WINDOW__X:
-			setX(X_EDEFAULT);
+			unsetX();
 			return;
 		case BasicPackageImpl.WINDOW__Y:
-			setY(Y_EDEFAULT);
+			unsetY();
 			return;
 		case BasicPackageImpl.WINDOW__WIDTH:
-			setWidth(WIDTH_EDEFAULT);
+			unsetWidth();
 			return;
 		case BasicPackageImpl.WINDOW__HEIGHT:
-			setHeight(HEIGHT_EDEFAULT);
+			unsetHeight();
 			return;
 		case BasicPackageImpl.WINDOW__WINDOWS:
 			getWindows().clear();
@@ -1023,13 +1173,13 @@
 		case BasicPackageImpl.WINDOW__MAIN_MENU:
 			return mainMenu != null;
 		case BasicPackageImpl.WINDOW__X:
-			return x != X_EDEFAULT;
+			return isSetX();
 		case BasicPackageImpl.WINDOW__Y:
-			return y != Y_EDEFAULT;
+			return isSetY();
 		case BasicPackageImpl.WINDOW__WIDTH:
-			return width != WIDTH_EDEFAULT;
+			return isSetWidth();
 		case BasicPackageImpl.WINDOW__HEIGHT:
-			return height != HEIGHT_EDEFAULT;
+			return isSetHeight();
 		case BasicPackageImpl.WINDOW__WINDOWS:
 			return windows != null && !windows.isEmpty();
 		case BasicPackageImpl.WINDOW__SHARED_ELEMENTS:
@@ -1257,13 +1407,25 @@
 		result.append(", variables: "); //$NON-NLS-1$
 		result.append(variables);
 		result.append(", x: "); //$NON-NLS-1$
-		result.append(x);
+		if (xESet)
+			result.append(x);
+		else
+			result.append("<unset>"); //$NON-NLS-1$
 		result.append(", y: "); //$NON-NLS-1$
-		result.append(y);
+		if (yESet)
+			result.append(y);
+		else
+			result.append("<unset>"); //$NON-NLS-1$
 		result.append(", width: "); //$NON-NLS-1$
-		result.append(width);
+		if (widthESet)
+			result.append(width);
+		else
+			result.append("<unset>"); //$NON-NLS-1$
 		result.append(", height: "); //$NON-NLS-1$
-		result.append(height);
+		if (heightESet)
+			result.append(height);
+		else
+			result.append("<unset>"); //$NON-NLS-1$
 		result.append(')');
 		return result.toString();
 	}
