diff --git a/ui/org.eclipse.pde.runtime/.classpath b/ui/org.eclipse.pde.runtime/.classpath
index 4c62a80..4f83b23 100644
--- a/ui/org.eclipse.pde.runtime/.classpath
+++ b/ui/org.eclipse.pde.runtime/.classpath
@@ -2,6 +2,6 @@
 <classpath>
 	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/ui/org.eclipse.pde.runtime/.settings/org.eclipse.jdt.core.prefs b/ui/org.eclipse.pde.runtime/.settings/org.eclipse.jdt.core.prefs
index 62ec106..519f9d0 100644
--- a/ui/org.eclipse.pde.runtime/.settings/org.eclipse.jdt.core.prefs
+++ b/ui/org.eclipse.pde.runtime/.settings/org.eclipse.jdt.core.prefs
@@ -8,9 +8,10 @@
 org.eclipse.jdt.core.classpath.exclusionPatterns=enabled
 org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.compliance=1.8
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
@@ -103,7 +104,7 @@
 org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=error
 org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
 org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
-org.eclipse.jdt.core.compiler.source=1.6
+org.eclipse.jdt.core.compiler.source=1.8
 org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
diff --git a/ui/org.eclipse.pde.runtime/META-INF/MANIFEST.MF b/ui/org.eclipse.pde.runtime/META-INF/MANIFEST.MF
index 9847de0..778f97c 100644
--- a/ui/org.eclipse.pde.runtime/META-INF/MANIFEST.MF
+++ b/ui/org.eclipse.pde.runtime/META-INF/MANIFEST.MF
@@ -2,14 +2,19 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %name
 Bundle-SymbolicName: org.eclipse.pde.runtime; singleton:=true
-Bundle-Version: 3.5.100.qualifier
+Bundle-Version: 3.6.0.qualifier
 Bundle-Activator: org.eclipse.pde.internal.runtime.PDERuntimePlugin
 Bundle-Vendor: %provider-name
 Bundle-Localization: plugin
-Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.11.0,4.0.0)",
+Require-Bundle: org.eclipse.core.databinding;bundle-version="1.6.0",
+ org.eclipse.core.databinding.observable;bundle-version="1.6.0",
+ org.eclipse.core.databinding.property;bundle-version="1.6.0",
+ org.eclipse.core.runtime;bundle-version="[3.11.0,4.0.0)",
  org.eclipse.ui;bundle-version="[3.3.0,4.0.0)",
  org.eclipse.ui.forms;bundle-version="[3.3.0,4.0.0)",
+ org.eclipse.jdt.annotation;bundle-version="2.1.0",
  org.eclipse.jdt.core;bundle-version="[3.3.0,4.0.0)";resolution:=optional,
+ org.eclipse.jface.databinding;bundle-version="1.8.0",
  org.eclipse.core.resources;bundle-version="[3.3.0,4.0.0)";resolution:=optional,
  org.eclipse.jdt.ui;bundle-version="[3.3.0,4.0.0)";resolution:=optional,
  org.eclipse.pde.ui;bundle-version="[3.3.0,4.0.0)";resolution:=optional,
@@ -22,5 +27,5 @@
  org.eclipse.pde.internal.runtime.spy.dialogs;x-internal:=true,
  org.eclipse.pde.internal.runtime.spy.handlers;x-internal:=true,
  org.eclipse.pde.internal.runtime.spy.sections;x-internal:=true
-Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
diff --git a/ui/org.eclipse.pde.runtime/icons/elcl16/up_nav.png b/ui/org.eclipse.pde.runtime/icons/elcl16/up_nav.png
new file mode 100644
index 0000000..a9830bc
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/icons/elcl16/up_nav.png
Binary files differ
diff --git a/ui/org.eclipse.pde.runtime/icons/elcl16/up_nav@2x.png b/ui/org.eclipse.pde.runtime/icons/elcl16/up_nav@2x.png
new file mode 100644
index 0000000..adaef6d
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/icons/elcl16/up_nav@2x.png
Binary files differ
diff --git a/ui/org.eclipse.pde.runtime/icons/obj16/layoutspy_obj.png b/ui/org.eclipse.pde.runtime/icons/obj16/layoutspy_obj.png
new file mode 100644
index 0000000..c729f06
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/icons/obj16/layoutspy_obj.png
Binary files differ
diff --git a/ui/org.eclipse.pde.runtime/plugin.properties b/ui/org.eclipse.pde.runtime/plugin.properties
index 1439826..82eeec5 100644
--- a/ui/org.eclipse.pde.runtime/plugin.properties
+++ b/ui/org.eclipse.pde.runtime/plugin.properties
@@ -21,5 +21,7 @@
 spy-category.name = Spy
 spy-command.name = Plug-in Selection Spy
 spy-command.description = Show the Plug-in Spy
+spy-layout-command.name = Layout Spy
+spy-layout-command.description = Show the Layout Spy
 spy-menu-command.name = Plug-in Menu Spy
 
diff --git a/ui/org.eclipse.pde.runtime/plugin.xml b/ui/org.eclipse.pde.runtime/plugin.xml
index 0824cb2..605627a 100644
--- a/ui/org.eclipse.pde.runtime/plugin.xml
+++ b/ui/org.eclipse.pde.runtime/plugin.xml
@@ -46,6 +46,12 @@
             id="org.eclipse.pde.runtime.spy.commands.menuSpyCommand"
             name="%spy-menu-command.name">
       </command>
+      <command
+            categoryId="org.eclipse.pde.runtime.spy.commands.category"
+            description="%spy-layout-command.description"
+            id="org.eclipse.pde.runtime.spy.commands.layoutSpyCommand"
+            name="%spy-layout-command.name">
+      </command>
    </extension>
    <extension
          point="org.eclipse.ui.commandImages">
@@ -57,6 +63,10 @@
             commandId="org.eclipse.pde.runtime.spy.commands.menuSpyCommand"
             icon="$nl$/icons/obj16/menuspy_obj.gif">
       </image>
+      <image
+            commandId="org.eclipse.pde.runtime.spy.commands.layoutSpyCommand"
+            icon="$nl$/icons/obj16/layoutspy_obj.png">
+      </image>
    </extension>
    <extension
          point="org.eclipse.ui.bindings">
@@ -87,6 +97,12 @@
             schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
             sequence="M3+M2+F2">
       </key>
+      <key
+            commandId="org.eclipse.pde.runtime.spy.commands.layoutSpyCommand"
+            contextId="org.eclipse.ui.contexts.dialogAndWindow"
+            schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
+            sequence="M1+M2+M3+F9">
+      </key>
    </extension>
    <extension
          point="org.eclipse.ui.handlers">
@@ -98,6 +114,10 @@
             class="org.eclipse.pde.internal.runtime.spy.handlers.MenuSpyHandler"
             commandId="org.eclipse.pde.runtime.spy.commands.menuSpyCommand">
       </handler>
+      <handler
+            class="org.eclipse.pde.internal.runtime.spy.handlers.LayoutSpyHandler"
+            commandId="org.eclipse.pde.runtime.spy.commands.layoutSpyCommand">
+      </handler>
    </extension>
 
 </plugin>
diff --git a/ui/org.eclipse.pde.runtime/pom.xml b/ui/org.eclipse.pde.runtime/pom.xml
index 0c15e27..a0aa311 100644
--- a/ui/org.eclipse.pde.runtime/pom.xml
+++ b/ui/org.eclipse.pde.runtime/pom.xml
@@ -20,7 +20,7 @@
   </parent>
   <groupId>org.eclipse.pde</groupId>
   <artifactId>org.eclipse.pde.runtime</artifactId>
-  <version>3.5.100-SNAPSHOT</version>
+  <version>3.6.0-SNAPSHOT</version>
   <packaging>eclipse-plugin</packaging>
 
   <properties>
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/PDERuntimePluginImages.java b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/PDERuntimePluginImages.java
index 1b83d09..a12c0b3 100644
--- a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/PDERuntimePluginImages.java
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/PDERuntimePluginImages.java
@@ -39,6 +39,7 @@
 	public static final String IMG_CONTEXTID_OBJ = "contextid_obj.gif"; //$NON-NLS-1$
 	public static final String IMG_SAVE_IMAGE_AS_OBJ = "save_image_as_obj.gif"; //$NON-NLS-1$
 	public static final String IMG_COPY_QNAME = "cpyqual_menu.gif"; //$NON-NLS-1$
+	public static final String IMG_UP_NAV = "up_nav.png"; //$NON-NLS-1$
 
 	public static final ImageDescriptor CLASS_OBJ = create(PATH_OBJ, IMG_CLASS_OBJ);
 	public static final ImageDescriptor INTERFACE_OBJ = create(PATH_OBJ, IMG_INTERFACE_OBJ);
@@ -50,6 +51,7 @@
 	public static final ImageDescriptor CONTEXTID_OBJ = create(PATH_OBJ, IMG_CONTEXTID_OBJ);
 	public static final ImageDescriptor SAVE_IMAGE_AS_OBJ = create(PATH_OBJ, IMG_SAVE_IMAGE_AS_OBJ);
 	public static final ImageDescriptor COPY_QNAME = create(PATH_LCL, IMG_COPY_QNAME);
+	public static final ImageDescriptor UP_NAV = create(PATH_LCL, IMG_UP_NAV);
 
 	public static final ImageDescriptor DESC_REFRESH_DISABLED = create(PATH_DCL, "refresh.gif"); //$NON-NLS-1$
 	public static final ImageDescriptor DESC_REFRESH = create(PATH_LCL, "refresh.gif"); //$NON-NLS-1$
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/ControlSelector.java b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/ControlSelector.java
new file mode 100644
index 0000000..e508ec6
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/ControlSelector.java
@@ -0,0 +1,197 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Google Inc and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Stefan Xenos (Google) - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.pde.internal.runtime.spy.dialogs;
+
+import java.util.ArrayList;
+import java.util.function.Consumer;
+import org.eclipse.core.databinding.observable.value.WritableValue;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jface.databinding.swt.WidgetSideEffects;
+import org.eclipse.jface.resource.JFaceResources;
+import org.eclipse.jface.resource.LocalResourceManager;
+import org.eclipse.jface.util.Geometry;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.DisposeEvent;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.widgets.*;
+
+/**
+ * Creates an overlay that allows the user to select any SWT control by moving
+ * the mouse and clicking. Once the user selects the control or presses ESC, the
+ * overlay is closed.
+ */
+public class ControlSelector {
+	private static final int EDGE_SIZE = 4;
+
+	private Shell overlay;
+	private LocalResourceManager resources;
+	private Color selectionRectangleColor;
+	private Display display;
+	private WritableValue<@Nullable Control> currentSelection = new WritableValue<>(null, null);
+	private Region region;
+	private Consumer<@Nullable Control> callback;
+	private Listener moveFilter = this::mouseMove;
+	private Listener selectFilter = this::select;
+
+	/**
+	 * Instantiates and opens the control selector.
+	 *
+	 * @param resultCallback
+	 *            callback that will be invoked when the overlay is closed. If
+	 *            the user selected a control, that control is passed to the
+	 *            callback. If the user cancelled the overlay, null is passed.
+	 */
+	public ControlSelector(Consumer<@Nullable Control> resultCallback) {
+		this.callback = resultCallback;
+		display = Display.getCurrent();
+		overlay = new Shell(SWT.ON_TOP | SWT.NO_TRIM);
+		overlay.addPaintListener(this::paint);
+		resources = new LocalResourceManager(JFaceResources.getResources(), overlay);
+		selectionRectangleColor = resources.createColor(new RGB(255, 255, 0));
+		display.addFilter(SWT.MouseMove, moveFilter);
+		display.addFilter(SWT.MouseDown, selectFilter);
+		overlay.addDisposeListener(this::disposed);
+		region = new Region();
+		WidgetSideEffects.createFactory(overlay).create(currentSelection::getValue, this::updateRegion);
+	}
+
+	private void updateRegion(@Nullable Control newControl) {
+		if (newControl == null) {
+			overlay.setVisible(false);
+			return;
+		}
+		overlay.setBounds(newControl.getMonitor().getClientArea());
+		Rectangle parentBoundsWrtDisplay = GeometryUtil.getDisplayBounds(newControl);
+		Rectangle parentBoundsWrtOverlay = Geometry.toControl(overlay, parentBoundsWrtDisplay);
+		Rectangle innerBoundsWrtOverlay = Geometry.copy(parentBoundsWrtOverlay);
+		Geometry.expand(innerBoundsWrtOverlay, -EDGE_SIZE, -EDGE_SIZE, -EDGE_SIZE, -EDGE_SIZE);
+		region.dispose();
+		region = new Region();
+		region.add(parentBoundsWrtOverlay);
+		region.subtract(innerBoundsWrtOverlay);
+		overlay.setRegion(region);
+		overlay.setVisible(true);
+	}
+
+	private void disposed(DisposeEvent e) {
+		currentSelection.dispose();
+		region.dispose();
+		display.removeFilter(SWT.MouseMove, moveFilter);
+		display.removeFilter(SWT.MouseDown, selectFilter);
+	}
+
+	private void select(Event e) {
+		closeWithResult(this.currentSelection.getValue());
+		e.doit = false;
+	}
+
+	private void closeWithResult(@Nullable Control result) {
+		display.removeFilter(SWT.MouseMove, moveFilter);
+		display.removeFilter(SWT.MouseDown, selectFilter);
+		overlay.dispose();
+		callback.accept(result);
+	}
+
+	/**
+	 * Finds and returns the most specific SWT control at the given location.
+	 * (Note: this does a DFS on the SWT widget hierarchy, which is slow).
+	 *
+	 * @param displayToSearch
+	 * @param locationToFind
+	 * @return the most specific SWT control at the given location
+	 */
+	public static Control findControl(Display displayToSearch, Shell toIgnore, Point locationToFind) {
+		Shell[] shells = displayToSearch.getShells();
+
+		ArrayList<Shell> shellList = new ArrayList<>();
+		for (Shell next : shells) {
+			if (next == toIgnore) {
+				continue;
+			}
+			shellList.add(next);
+		}
+
+		shells = shellList.toArray(new Shell[shellList.size()]);
+
+		return findControl(shells, locationToFind);
+	}
+
+	/**
+	 * Finds the control at the given location.
+	 *
+	 * @param toSearch
+	 * @param locationToFind
+	 *            location (in display coordinates)
+	 * @return the control at the given location
+	 */
+	public static Control findControl(Composite toSearch, Point locationToFind) {
+		Control[] children = toSearch.getChildren();
+
+		return findControl(children, locationToFind);
+	}
+
+	/**
+	 * Searches the given list of controls for a control containing the given
+	 * point. If the array contains any composites, those composites will be
+	 * recursively searched to find the most specific child that contains the
+	 * point.
+	 *
+	 * @param toSearch
+	 *            an array of composites
+	 * @param locationToFind
+	 *            a point (in display coordinates)
+	 * @return the most specific Control that overlaps the given point, or null
+	 *         if none
+	 */
+	public static Control findControl(Control[] toSearch, Point locationToFind) {
+		for (int idx = toSearch.length - 1; idx >= 0; idx--) {
+			Control next = toSearch[idx];
+
+			if (!next.isDisposed() && next.isVisible()) {
+
+				Rectangle bounds = GeometryUtil.getDisplayBounds(next);
+
+				if (bounds.contains(locationToFind)) {
+					if (next instanceof Composite) {
+						Control result = findControl((Composite) next, locationToFind);
+
+						if (result != null) {
+							return result;
+						}
+					}
+
+					return next;
+				}
+			}
+		}
+
+		return null;
+	}
+
+	private void mouseMove(Event e) {
+		Point globalPoint = new Point(e.x, e.y);
+		if (e.widget instanceof Control) {
+			Control control = (Control) e.widget;
+
+			globalPoint = control.toDisplay(globalPoint);
+		}
+		Control control = findControl(Display.getCurrent(), overlay, globalPoint);
+		currentSelection.setValue(control);
+	}
+
+	protected void paint(PaintEvent e) {
+		e.gc.setBackground(selectionRectangleColor);
+		e.gc.fillRectangle(overlay.getClientArea());
+	}
+
+}
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/GeometryUtil.java b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/GeometryUtil.java
new file mode 100644
index 0000000..57d5ae8
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/GeometryUtil.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Google Inc and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Stefan Xenos (Google) - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.pde.internal.runtime.spy.dialogs;
+
+import org.eclipse.jface.util.Geometry;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Shell;
+
+public class GeometryUtil {
+	public static Rectangle getDisplayBounds(Control boundsControl) {
+		Control parent = boundsControl.getParent();
+		if (parent == null || boundsControl instanceof Shell) {
+			return boundsControl.getBounds();
+		}
+	
+		return Geometry.toDisplay(parent, boundsControl.getBounds());
+	}
+
+	public static Rectangle extrudeEdge(Rectangle innerBoundsWrtOverlay, int distanceToTop, int side) {
+		if (distanceToTop <= 0) {
+			return new Rectangle(0, 0, 0, 0);
+		}
+		return Geometry.getExtrudedEdge(innerBoundsWrtOverlay, distanceToTop, side);
+	}
+
+	public static int getBottom(Rectangle rect) {
+		return rect.y + rect.height;
+	}
+
+	public static int getRight(Rectangle rect) {
+		return rect.x + rect.width;
+	}
+}
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/LayoutSpyDialog.java b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/LayoutSpyDialog.java
new file mode 100644
index 0000000..17252c3
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/LayoutSpyDialog.java
@@ -0,0 +1,735 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Google Inc and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Stefan Xenos (Google) - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.pde.internal.runtime.spy.dialogs;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.List;
+import org.eclipse.core.databinding.observable.list.ComputedList;
+import org.eclipse.core.databinding.observable.sideeffect.ISideEffectFactory;
+import org.eclipse.core.databinding.observable.value.WritableValue;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jface.databinding.swt.*;
+import org.eclipse.jface.databinding.viewers.*;
+import org.eclipse.jface.layout.*;
+import org.eclipse.jface.resource.*;
+import org.eclipse.jface.util.Geometry;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.pde.internal.runtime.PDERuntimePluginImages;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.layout.*;
+import org.eclipse.swt.widgets.*;
+
+/**
+ * Implementation of the "layout spy" dialog, a diagnostic tool for fixing bugs
+ * related to control positioning and the implementation of SWT {@link Control}s
+ * and {@link Layout}s.
+ */
+public class LayoutSpyDialog {
+	private static final int EDGE_SIZE = 4;
+	private static final RGB SELECTED_PARENT_OVERLAY_COLOR = new RGB(255, 0, 0);
+	private static final RGB SELECTED_CHILD_OVERLAY_COLOR = new RGB(255, 255, 0);
+
+	/**
+	 * Value used to indicate an unknown hint value
+	 */
+	private static final int UNKNOWN = -2;
+	private Shell shell;
+
+	// Controls
+	private TableViewer childList;
+	private Text details;
+	private Button selectWidgetButton;
+	private Button goUpButton;
+	private Button goDownButton;
+	private Shell overlay;
+
+	// Model
+	private WritableValue<@Nullable Composite> parentControl = new WritableValue<>(null, null);
+	private WritableValue<Boolean> controlSelectorOpen = new WritableValue<>(Boolean.FALSE, null);
+	private ComputedList<Control> listContents;
+	private IViewerObservableValue selectedChild;
+	private Color parentRectangleColor;
+	private Color childRectangleColor;
+	private ResourceManager resources;
+	private Region region;
+	private ISWTObservableValue overlayEnabled;
+	private Image upImage;
+	private Text diagnostics;
+
+	/**
+	 * Creates the dialog but does not make it visible.
+	 * 
+	 * @param parentShell
+	 *            the parent shell
+	 */
+	public LayoutSpyDialog(Shell parentShell) {
+		overlay = new Shell(SWT.ON_TOP | SWT.NO_TRIM);
+		{
+			overlay.addPaintListener(this::paintOverlay);
+			region = new Region();
+			overlay.addDisposeListener((DisposeEvent) -> {
+				region.dispose();
+			});
+			overlay.setRegion(region);
+		}
+
+		shell = new Shell(parentShell, SWT.SHELL_TRIM);
+
+		resources = new LocalResourceManager(JFaceResources.getResources(), shell);
+		parentRectangleColor = resources.createColor(SELECTED_PARENT_OVERLAY_COLOR);
+		childRectangleColor = resources.createColor(SELECTED_CHILD_OVERLAY_COLOR);
+		upImage = resources.createImage(PDERuntimePluginImages.UP_NAV);
+
+		Composite infoRegion = new Composite(shell, SWT.NONE);
+		{
+			Composite headerRegion = new Composite(infoRegion, SWT.NONE);
+			{
+				Button upButton = new Button(headerRegion, SWT.PUSH | SWT.CENTER);
+				upButton.setImage(upImage);
+				upButton.addListener(SWT.Selection, event -> goUp());
+				GridDataFactory.fillDefaults().applyTo(upButton);
+
+				Label childrenLabel = new Label(headerRegion, SWT.NONE);
+				childrenLabel.setText(Messages.LayoutSpyDialog_label_children);
+			}
+			GridLayoutFactory.fillDefaults().numColumns(2).generateLayout(headerRegion);
+
+			Label detailsLabel = new Label(infoRegion, SWT.NONE);
+			detailsLabel.setText(Messages.LayoutSpyDialog_label_layout);
+
+			childList = new TableViewer(infoRegion);
+			details = new Text(infoRegion, SWT.READ_ONLY | SWT.MULTI | SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
+			GridDataFactory.fillDefaults().hint(300, 300).grab(true, true).applyTo(details);
+
+			GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(true).generateLayout(infoRegion);
+		}
+
+		diagnostics = new Text(shell, SWT.READ_ONLY | SWT.MULTI | SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
+		GridDataFactory.fillDefaults().hint(300, 300).grab(true, true).applyTo(diagnostics);
+
+		Button showOverlayButton = new Button(shell, SWT.CHECK);
+		showOverlayButton.setText(Messages.LayoutSpyDialog_button_show_overlay);
+
+		Composite buttonBar = new Composite(shell, SWT.NONE);
+		{
+			selectWidgetButton = new Button(buttonBar, SWT.PUSH);
+			selectWidgetButton.setText(Messages.LayoutSpyDialog_button_select_control);
+			goUpButton = new Button(buttonBar, SWT.PUSH);
+			goUpButton.setText(Messages.LayoutSpyDialog_button_open_parent);
+			goDownButton = new Button(buttonBar, SWT.PUSH);
+			goDownButton.setText(Messages.LayoutSpyDialog_button_open_child);
+
+			GridLayoutFactory.fillDefaults().numColumns(3).generateLayout(buttonBar);
+		}
+		GridDataFactory.fillDefaults().align(SWT.CENTER, SWT.CENTER).applyTo(buttonBar);
+
+		GridLayoutFactory.fillDefaults().margins(LayoutConstants.getMargins()).generateLayout(shell);
+
+		// Attach listeners
+		shell.addDisposeListener(event -> disposed());
+		selectWidgetButton.addListener(SWT.Selection, event -> selectControl());
+		goUpButton.addListener(SWT.Selection, event -> goUp());
+		goDownButton.addListener(SWT.Selection, event -> goDown());
+		childList.addOpenListener(event -> {
+			goDown();
+		});
+
+		// Set up the model
+		selectedChild = ViewerProperties.singleSelection().observe(childList);
+		overlayEnabled = WidgetProperties.selection().observe(showOverlayButton);
+		childList.setContentProvider(new ObservableListContentProvider());
+		listContents = new ComputedList<Control>() {
+			@Override
+			protected List<Control> calculate() {
+				Composite control = parentControl.getValue();
+				if (control == null) {
+					return Arrays.asList(Display.getCurrent().getShells());
+				}
+				return Arrays.asList(control.getChildren());
+			}
+		};
+		childList.setInput(listContents);
+		ISideEffectFactory sideEffectFactory = WidgetSideEffects.createFactory(shell);
+		sideEffectFactory.create(this::computeParentInfo, details::setText);
+		sideEffectFactory.create(this::computeChildInfo, diagnostics::setText);
+		sideEffectFactory.create(this::updateOverlay);
+
+		openComposite(parentShell);
+	}
+
+	/**
+	 * Opens the dialog box, revealing it to the user.
+	 */
+	public void open() {
+		this.shell.pack();
+		this.shell.open();
+	}
+
+	/**
+	 * Disposes the dialog box.
+	 */
+	public void close() {
+		this.shell.dispose();
+	}
+
+	/**
+	 * Invoked as a callback when the main shell is disposed.
+	 */
+	private void disposed() {
+		listContents.dispose();
+		selectedChild.dispose();
+		parentControl.dispose();
+
+		overlay.dispose();
+	}
+
+	private void openComposite(Composite composite) {
+		parentControl.setValue(composite);
+	}
+
+	/**
+	 * Returns the currently-selected child control or null if none.
+	 */
+	private @Nullable Control getSelectedChild() {
+		return (@Nullable Control) selectedChild.getValue();
+	}
+
+	/**
+	 * Opens the given control in the layout spy.
+	 */
+	@SuppressWarnings("unchecked")
+	private void openControl(Control control) {
+		Composite parent = control.getParent();
+
+		if (parent == null) {
+			if (control instanceof Composite) {
+				parentControl.setValue((Composite) control);
+			}
+		} else {
+			parentControl.setValue(parent);
+			selectedChild.setValue(control);
+		}
+	}
+
+	// Overlay management
+	// -----------------------------------------------------------------
+
+	/**
+	 * This callback is used to update the bounds and visible region for the
+	 * overlay shell. It is used as part of a side-effect, so if it makes use of
+	 * any tracked getters, it will automatically be invoked again whenever one
+	 * of those tracked getters changes state.
+	 *
+	 * @TrackedGetter
+	 */
+	public void updateOverlay() {
+		@Nullable
+		Composite parent = parentControl.getValue();
+
+		boolean enabled = Boolean.TRUE.equals(overlayEnabled.getValue());
+
+		overlay.setVisible(parent != null && !controlSelectorOpen.getValue() && enabled);
+		if (parent == null) {
+			return;
+		}
+		Shell shell = parent.getShell();
+		Rectangle outerBounds = Geometry.copy(shell.getBounds());
+		overlay.setBounds(outerBounds);
+		Rectangle parentBoundsWrtDisplay = GeometryUtil.getDisplayBounds(parent);
+
+		Rectangle parentBoundsWrtOverlay = Geometry.toControl(overlay, parentBoundsWrtDisplay);
+		Rectangle innerBoundsWrtOverlay = Geometry.copy(parentBoundsWrtOverlay);
+		Geometry.expand(innerBoundsWrtOverlay, -EDGE_SIZE, -EDGE_SIZE, -EDGE_SIZE, -EDGE_SIZE);
+		region.dispose();
+		region = new Region();
+		@Nullable
+		Control child = (@Nullable Control) selectedChild.getValue();
+		if (child != null) {
+			Rectangle childBoundsWrtOverlay = Geometry.toControl(overlay, GeometryUtil.getDisplayBounds(child));
+			Rectangle childInnerBoundsWrtOverlay = Geometry.copy(childBoundsWrtOverlay);
+			Geometry.expand(childInnerBoundsWrtOverlay, -EDGE_SIZE, -EDGE_SIZE, -EDGE_SIZE, -EDGE_SIZE);
+			region.add(parentBoundsWrtOverlay);
+			int distanceToTop = childBoundsWrtOverlay.y - innerBoundsWrtOverlay.y;
+			subtractRect(region, GeometryUtil.extrudeEdge(innerBoundsWrtOverlay, distanceToTop, SWT.TOP));
+			int distanceToLeft = childBoundsWrtOverlay.x - innerBoundsWrtOverlay.x;
+			subtractRect(region, GeometryUtil.extrudeEdge(innerBoundsWrtOverlay, distanceToLeft, SWT.LEFT));
+			int distanceToRight = GeometryUtil.getRight(innerBoundsWrtOverlay) - GeometryUtil.getRight(childBoundsWrtOverlay);
+			subtractRect(region, GeometryUtil.extrudeEdge(innerBoundsWrtOverlay, distanceToRight, SWT.RIGHT));
+			int distanceToBottom = GeometryUtil.getBottom(innerBoundsWrtOverlay) - GeometryUtil.getBottom(childBoundsWrtOverlay);
+			subtractRect(region, GeometryUtil.extrudeEdge(innerBoundsWrtOverlay, distanceToBottom, SWT.BOTTOM));
+
+			subtractRect(region, childInnerBoundsWrtOverlay);
+		} else {
+			region.add(parentBoundsWrtOverlay);
+			region.subtract(innerBoundsWrtOverlay);
+		}
+
+		overlay.redraw();
+		overlay.setRegion(region);
+	}
+
+	/**
+	 * Paint callback for the overlay shell. This draws rectangles around the
+	 * selected layout and the selected child.
+	 */
+	protected void paintOverlay(PaintEvent e) {
+		@Nullable
+		Composite parent = parentControl.getValue();
+		if (parent == null) {
+			return;
+		}
+		int halfSize = EDGE_SIZE / 2;
+		Rectangle parentDisplayBounds = GeometryUtil.getDisplayBounds(parent);
+		Rectangle parentBoundsWrtOverlay = Geometry.toControl(overlay, parentDisplayBounds);
+		Geometry.expand(parentBoundsWrtOverlay, -halfSize, -halfSize, -halfSize, -halfSize);
+
+		@Nullable
+		Control child = (@Nullable Control) selectedChild.getValue();
+		e.gc.setLineWidth(EDGE_SIZE);
+		e.gc.setForeground(parentRectangleColor);
+		e.gc.drawRectangle(parentBoundsWrtOverlay.x, parentBoundsWrtOverlay.y, parentBoundsWrtOverlay.width,
+				parentBoundsWrtOverlay.height);
+
+		if (child != null) {
+			Rectangle childBoundsWrtOverlay = Geometry.toControl(overlay, GeometryUtil.getDisplayBounds(child));
+			Geometry.expand(childBoundsWrtOverlay, -halfSize, -halfSize, -halfSize, -halfSize);
+			e.gc.setForeground(childRectangleColor);
+			e.gc.drawRectangle(childBoundsWrtOverlay.x, childBoundsWrtOverlay.y, childBoundsWrtOverlay.width,
+					childBoundsWrtOverlay.height);
+		}
+	}
+
+	// User gesture callbacks
+	// -----------------------------------------------------------
+
+	/**
+	 * Invoked when the user clicks the "select control" button. It opens some
+	 * UI that allows the user to select a new input control for the layout spy.
+	 */
+	private void selectControl() {
+		this.controlSelectorOpen.setValue(true);
+		this.shell.setVisible(false);
+		new ControlSelector((@Nullable Control control) -> {
+			if (control != null) {
+				openControl(control);
+			}
+			this.controlSelectorOpen.setValue(false);
+			this.shell.setVisible(true);
+		});
+	}
+
+	/**
+	 * Invoked when the user clicks the "go up" button, which opens the parent.
+	 */
+	@SuppressWarnings("unchecked")
+	private void goUp() {
+		@Nullable
+		Composite parent = parentControl.getValue();
+		if (parent == null) {
+			return;
+		}
+		Composite ancestor = parent.getParent();
+		openComposite(ancestor);
+		this.selectedChild.setValue(parent);
+	}
+
+	/**
+	 * Invoked when the user clicks the "go down" button, which opens the
+	 * selected child.
+	 */
+	private void goDown() {
+		Control child = getSelectedChild();
+		if (child instanceof Composite) {
+			Composite composite = (Composite) child;
+			openComposite(composite);
+		}
+	}
+
+	// Utility functions -----------------------------------------------------
+
+	/**
+	 * Subtracts the given rectangle from the given region unless the rectangle
+	 * is empty.
+	 */
+	private static void subtractRect(Region region, Rectangle rect) {
+		if (rect.isEmpty()) {
+			return;
+		}
+		region.subtract(rect);
+	}
+
+	private String getWarningMessage(String string) {
+		return NLS.bind(Messages.LayoutSpyDialog_warning_prefix, string);
+	}
+
+	private static String printHint(int hint) {
+		if (hint == SWT.DEFAULT) {
+			return "SWT.DEFAULT"; //$NON-NLS-1$
+		}
+		return Integer.toString(hint);
+	}
+
+	private static String printPoint(Point toPrint) {
+		return NLS.bind("({0}, {1})", new Object[] { toPrint.x, toPrint.y }); //$NON-NLS-1$
+	}
+
+	// Control classification ------------------------------------------------
+
+	private static boolean isHorizontallyScrollable(Control child) {
+		return (child.getStyle() & SWT.H_SCROLL) != 0;
+	}
+
+	private static boolean isVerticallyScrollable(Control child) {
+		return (child.getStyle() & SWT.V_SCROLL) != 0;
+	}
+
+	/**
+	 * Computes the values that should be subtracted off the width and height
+	 * hints from computeSize on the given control.
+	 */
+	private static Point computeHintAdjustment(Control control) {
+		int widthAdjustment;
+		int heightAdjustment;
+		if (control instanceof Scrollable) {
+			// For composites, subtract off the trim size
+			Scrollable composite = (Scrollable) control;
+			Rectangle trim = composite.computeTrim(0, 0, 0, 0);
+
+			widthAdjustment = trim.width;
+			heightAdjustment = trim.height;
+		} else {
+			// For non-composites, subtract off 2 * the border size
+			widthAdjustment = control.getBorderWidth() * 2;
+			heightAdjustment = widthAdjustment;
+		}
+
+		return new Point(widthAdjustment, heightAdjustment);
+	}
+
+	/**
+	 * Returns true if the given control is a composite which can expand in the
+	 * given dimension. Returns false if the control either cannot expand in the
+	 * given dimension or if its growable characteristics cannot be computed in
+	 * that dimension.
+	 */
+	private static boolean isGrowableLayout(Control control, boolean horizontal) {
+		if (control instanceof Composite) {
+			Composite composite = (Composite) control;
+
+			Layout theLayout = composite.getLayout();
+			if (theLayout instanceof GridLayout) {
+				Control[] children = composite.getChildren();
+				for (int i = 0; i < children.length; i++) {
+					Control child = children[i];
+
+					GridData data = (GridData) child.getLayoutData();
+
+					if (data != null) {
+						if (horizontal) {
+							if (data.grabExcessHorizontalSpace) {
+								return true;
+							}
+						} else {
+							if (data.grabExcessVerticalSpace) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Returns true iff another visible widget in the same shell overlaps the
+	 * given control.
+	 */
+	private static boolean overlapsSibling(Control toFind) {
+		Composite parent = toFind.getParent();
+		Control current = toFind;
+		Rectangle displayBounds = GeometryUtil.getDisplayBounds(toFind);
+
+		while (parent != null && !(parent instanceof Shell)) {
+			for (Control nextSibling : parent.getChildren()) {
+				if (nextSibling == current) {
+					continue;
+				}
+				if (!nextSibling.isVisible()) {
+					continue;
+				}
+				Rectangle nextSiblingBounds = GeometryUtil.getDisplayBounds(nextSibling);
+				if (nextSiblingBounds.intersects(displayBounds)) {
+					return true;
+				}
+			}
+			current = parent;
+			parent = parent.getParent();
+		}
+		return false;
+	}
+
+	/**
+	 * Computes the string that will be shown in the text box which displays
+	 * information about the selected child. This is a tracked getter -- if it
+	 * reads from a databinding observable, the text box will automatically
+	 * refresh in response to changes in that observable.
+	 * 
+	 * @TrackedGetter
+	 */
+	private String computeChildInfo() {
+		StringBuilder builder = new StringBuilder();
+		Control child = getSelectedChild();
+
+		if (child != null) {
+			builder.append(child.getClass().getName());
+			builder.append("\n\n"); //$NON-NLS-1$
+
+			int widthHintFromLayoutData = UNKNOWN;
+			int heightHintFromLayoutData = UNKNOWN;
+			Object layoutData = child.getLayoutData();
+			if (layoutData == null) {
+				builder.append("getLayoutData() == null\n"); //$NON-NLS-1$
+			} else if (layoutData instanceof GridData) {
+				GridData grid = (GridData) layoutData;
+				builder.append(GridDataFactory.createFrom(grid));
+				widthHintFromLayoutData = grid.widthHint;
+				heightHintFromLayoutData = grid.heightHint;
+
+				if (!grid.grabExcessHorizontalSpace) {
+					if (isHorizontallyScrollable(child) || isGrowableLayout(child, true)) {
+						builder.append(getWarningMessage(
+								Messages.LayoutSpyDialog_warning_grab_horizontally_scrolling));
+					}
+				}
+				if (!grid.grabExcessVerticalSpace) {
+					if (isVerticallyScrollable(child) || isGrowableLayout(child, false)) {
+						builder.append(getWarningMessage(
+								Messages.LayoutSpyDialog_warning_grab_vertical_scrolling));
+					}
+				}
+			} else if (layoutData instanceof FormData) {
+				FormData data = (FormData) layoutData;
+
+				widthHintFromLayoutData = data.width;
+				heightHintFromLayoutData = data.height;
+			} else {
+				describeObject(builder, "data", layoutData); //$NON-NLS-1$
+			}
+
+			if (isHorizontallyScrollable(child)) {
+				if (widthHintFromLayoutData == SWT.DEFAULT) {
+					builder.append(getWarningMessage(Messages.LayoutSpyDialog_warning_hint_for_horizontally_scrollable));
+				}
+			}
+
+			if (isVerticallyScrollable(child)) {
+				if (heightHintFromLayoutData == SWT.DEFAULT) {
+					builder.append(getWarningMessage(Messages.LayoutSpyDialog_warning_hint_for_vertically_scrollable));
+				}
+			}
+
+			builder.append("\n"); //$NON-NLS-1$
+
+			// Print the current dimensions
+			Rectangle bounds = child.getBounds();
+			builder.append(NLS.bind("getBounds() = {0}", bounds.toString())); //$NON-NLS-1$
+			builder.append("\n"); //$NON-NLS-1$
+
+			Point adjustment = computeHintAdjustment(child);
+
+			int widthHint = Math.max(0, bounds.width - adjustment.x);
+			int heightHint = Math.max(0, bounds.height - adjustment.y);
+
+			builder.append(NLS.bind("widthAdjustment = {0}, heightAdjustment = {1}", //$NON-NLS-1$
+					new Object[] { adjustment.x, adjustment.y }));
+			builder.append("\n\n"); //$NON-NLS-1$
+
+			// Print the default size
+			Point defaultSize = child.computeSize(SWT.DEFAULT, SWT.DEFAULT, false);
+			builder.append(NLS.bind("computeSize(SWT.DEFAULT, SWT.DEFAULT, false) = {0}", printPoint(defaultSize))); //$NON-NLS-1$
+			builder.append("\n"); //$NON-NLS-1$
+
+			// Print the preferred horizontally-wrapped size:
+			Point hWrappedSize = child.computeSize(widthHint, SWT.DEFAULT, false);
+			builder.append(NLS.bind("computeSize({0} - widthAdjustment, SWT.DEFAULT, false) = {1}", //$NON-NLS-1$
+					new Object[] { widthHint, printPoint(hWrappedSize) }));
+			builder.append("\n"); //$NON-NLS-1$
+
+			// Print the preferred vertically-wrapped size:
+			Point vWrappedSize = child.computeSize(SWT.DEFAULT, heightHint, false);
+			builder.append(NLS.bind("computeSize(SWT.DEFAULT, {0} - heightAdjustment, false) = {1}", //$NON-NLS-1$
+					new Object[] { heightHint, printPoint(vWrappedSize) }));
+			builder.append("\n"); //$NON-NLS-1$
+
+			// Check for warnings
+			Point noOpSize = child.computeSize(widthHint, heightHint, false);
+			if (noOpSize.x != bounds.width || noOpSize.y != bounds.height) {
+				builder.append(getWarningMessage(NLS.bind(Messages.LayoutSpyDialog_warning_unexpected_compute_size,
+						new Object[] { printHint(widthHint), printHint(heightHint), printPoint(noOpSize) })));
+			}
+
+			if (bounds.height < hWrappedSize.y) {
+				builder.append(
+						getWarningMessage(Messages.LayoutSpyDialog_warning_shorter_than_preferred_size));
+			}
+
+			printReasonControlIsInvisible(builder, child);
+		}
+		return builder.toString();
+	}
+
+	/**
+	 * If the control cannot be seen by the user, this method adds a warning
+	 * message to the given builder explaining the reason why the control cannot
+	 * be seen.
+	 */
+	private void printReasonControlIsInvisible(StringBuilder builder, Control control) {
+		if (!control.isVisible()) {
+			builder.append(getWarningMessage("isVisible() == false")); //$NON-NLS-1$
+			return;
+		}
+
+		Rectangle bounds = control.getBounds();
+		if (bounds.isEmpty()) {
+			builder.append(getWarningMessage(Messages.LayoutSpyDialog_warning_zero_size));
+			return;
+		}
+
+		Rectangle displayBounds = GeometryUtil.getDisplayBounds(control);
+
+		Composite parent = control.getParent();
+		if (parent != null) {
+			Rectangle parentDisplayBounds = GeometryUtil.getDisplayBounds(parent);
+
+			Rectangle intersection = displayBounds.intersection(parentDisplayBounds);
+			if (intersection.isEmpty()) {
+				builder.append(getWarningMessage(Messages.LayoutSpyDialog_warning_bounds_outside_parent));
+				return;
+			}
+
+			if (intersection.width < bounds.width || intersection.height < bounds.height) {
+				builder.append(getWarningMessage(Messages.LayoutSpyDialog_warning_control_partially_clipped));
+				return;
+			}
+
+			if (overlapsSibling(control)) {
+				builder.append(getWarningMessage(Messages.LayoutSpyDialog_warning_control_overlaps_siblings));
+				return;
+			}
+		}
+	}
+
+	/**
+	 * Computes the string that will be shown in the text box which displays
+	 * information about the selected layout. This is a tracked getter: if it
+	 * reads from an observable, the text box will update automatically when the
+	 * observable changes.
+	 * 
+	 * @TrackedGetter
+	 */
+	private String computeParentInfo() {
+		StringBuilder builder = new StringBuilder();
+		@Nullable
+		Composite parent = parentControl.getValue();
+
+		if (parent != null) {
+			builder.append(parent.getClass().getName());
+			builder.append("\n\n"); //$NON-NLS-1$
+
+			Rectangle parentBounds = GeometryUtil.getDisplayBounds(parent);
+			Layout layout = parent.getLayout();
+
+			if (layout != null) {
+				if (layout instanceof GridLayout) {
+					GridLayout grid = (GridLayout) layout;
+					builder.append(GridLayoutFactory.createFrom(grid));
+
+					boolean hasVerticallyTruncadeControls = false;
+					boolean hasHorizontallyTruncadeControls = false;
+
+					boolean hasHorizontalGrab = false;
+					boolean hasVerticalGrab = false;
+					for (Control next : parent.getChildren()) {
+						@Nullable
+						GridData data = (GridData) next.getLayoutData();
+						if (data == null) {
+							continue;
+						}
+
+						Rectangle childBounds = GeometryUtil.getDisplayBounds(parent);
+						Rectangle intersection = childBounds.intersection(parentBounds);
+
+						if (intersection.width < childBounds.width) {
+							hasHorizontallyTruncadeControls = true;
+						}
+
+						if (intersection.height < childBounds.height) {
+							hasVerticallyTruncadeControls = true;
+						}
+
+						hasHorizontalGrab = hasHorizontalGrab || data.grabExcessHorizontalSpace;
+						hasVerticalGrab = hasVerticalGrab || data.grabExcessVerticalSpace;
+					}
+
+					if (hasHorizontallyTruncadeControls && !hasHorizontalGrab) {
+						builder.append(getWarningMessage(
+								Messages.LayoutSpyDialog_warning_not_grabbing_horizontally));
+					}
+
+					if (hasVerticallyTruncadeControls && !hasVerticalGrab) {
+						builder.append(getWarningMessage(
+								Messages.LayoutSpyDialog_warning_not_grabbing_vertically));
+					}
+				} else {
+					describeObject(builder, "layout", layout); //$NON-NLS-1$
+				}
+			}
+		} else {
+			builder.append(Messages.LayoutSpyDialog_label_no_parent_control_selected);
+		}
+
+		return builder.toString();
+	}
+
+	/**
+	 * Uses reflection to print the values of the given object's public fields.
+	 */
+	void describeObject(StringBuilder result, String variableName, Object toDescribe) {
+		@SuppressWarnings("rawtypes")
+		Class clazz = toDescribe.getClass();
+		result.append(clazz.getName());
+		result.append(" "); //$NON-NLS-1$
+		result.append(variableName);
+		result.append(";\n"); //$NON-NLS-1$
+		Field[] fields = clazz.getFields();
+
+		for (Field nextField : fields) {
+			int modifiers = nextField.getModifiers();
+			if (!Modifier.isPublic(modifiers)) {
+				continue;
+			}
+			try {
+				String next = variableName + "." + nextField.getName() + " = " + nextField.get(toDescribe) + ";"; //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
+				result.append(next);
+				result.append("\n"); //$NON-NLS-1$
+			} catch (IllegalArgumentException | IllegalAccessException e) {
+				// Don't care
+			}
+		}
+	}
+}
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/Messages.java b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/Messages.java
new file mode 100644
index 0000000..145b1e2
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/Messages.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Google Inc and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Stefan Xenos (Google) - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.pde.internal.runtime.spy.dialogs;
+
+import org.eclipse.osgi.util.NLS;
+
+public class Messages extends NLS {
+	private static final String BUNDLE_NAME = "org.eclipse.pde.internal.runtime.spy.dialogs.messages"; //$NON-NLS-1$
+	public static String LayoutSpyDialog_button_open_child;
+	public static String LayoutSpyDialog_button_open_parent;
+	public static String LayoutSpyDialog_button_select_control;
+	public static String LayoutSpyDialog_button_show_overlay;
+	public static String LayoutSpyDialog_label_children;
+	public static String LayoutSpyDialog_label_layout;
+	public static String LayoutSpyDialog_label_no_parent_control_selected;
+	public static String LayoutSpyDialog_warning_bounds_outside_parent;
+	public static String LayoutSpyDialog_warning_control_overlaps_siblings;
+	public static String LayoutSpyDialog_warning_control_partially_clipped;
+	public static String LayoutSpyDialog_warning_grab_horizontally_scrolling;
+	public static String LayoutSpyDialog_warning_grab_vertical_scrolling;
+	public static String LayoutSpyDialog_warning_hint_for_horizontally_scrollable;
+	public static String LayoutSpyDialog_warning_hint_for_vertically_scrollable;
+	public static String LayoutSpyDialog_warning_not_grabbing_horizontally;
+	public static String LayoutSpyDialog_warning_not_grabbing_vertically;
+	public static String LayoutSpyDialog_warning_prefix;
+	public static String LayoutSpyDialog_warning_shorter_than_preferred_size;
+	public static String LayoutSpyDialog_warning_unexpected_compute_size;
+	public static String LayoutSpyDialog_warning_zero_size;
+	static {
+		// initialize resource bundle
+		NLS.initializeMessages(BUNDLE_NAME, Messages.class);
+	}
+
+	private Messages() {
+	}
+}
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/messages.properties b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/messages.properties
new file mode 100644
index 0000000..55cbd25
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/dialogs/messages.properties
@@ -0,0 +1,20 @@
+LayoutSpyDialog_button_open_child=Open &Child
+LayoutSpyDialog_button_open_parent=Open &Parent
+LayoutSpyDialog_button_select_control=Select &Control
+LayoutSpyDialog_button_show_overlay=Show &overlay
+LayoutSpyDialog_label_children=Children:
+LayoutSpyDialog_label_layout=Layout:
+LayoutSpyDialog_label_no_parent_control_selected=No parent control selected
+LayoutSpyDialog_warning_bounds_outside_parent=Control is located outside the bounds of its parent
+LayoutSpyDialog_warning_control_overlaps_siblings=Control overlaps one of its visible siblings
+LayoutSpyDialog_warning_control_partially_clipped=Control is being partially clipped by its parent
+LayoutSpyDialog_warning_grab_horizontally_scrolling=The grab horizontal flag is recommended for horizontally resizable controls
+LayoutSpyDialog_warning_grab_vertical_scrolling=The grab vertical flag is recommended for vertically resizable controls
+LayoutSpyDialog_warning_hint_for_horizontally_scrollable=Horizontally scrollable controls should have a width hint
+LayoutSpyDialog_warning_hint_for_vertically_scrollable=Vertically scrollable controls should have a height hint
+LayoutSpyDialog_warning_not_grabbing_horizontally=None of the controls use the horizontal grab flag, which may be the reason why some of the controls in the layout are truncated horizontally.
+LayoutSpyDialog_warning_not_grabbing_vertically=None of the controls use the vertical grab flag, which may be the reason why some of the controls in the layout are truncated vertically.
+LayoutSpyDialog_warning_prefix=WARNING: {0}\n
+LayoutSpyDialog_warning_shorter_than_preferred_size=The vertical size of this widget is shorter than its preferred size.
+LayoutSpyDialog_warning_unexpected_compute_size=computeSize({0}, {1}) returned unexpected size of {2}
+LayoutSpyDialog_warning_zero_size=Control has 0 size
diff --git a/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/handlers/LayoutSpyHandler.java b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/handlers/LayoutSpyHandler.java
new file mode 100644
index 0000000..556fa48
--- /dev/null
+++ b/ui/org.eclipse.pde.runtime/src/org/eclipse/pde/internal/runtime/spy/handlers/LayoutSpyHandler.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2016 Google Inc and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Stefan Xenos (Google) - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.pde.internal.runtime.spy.handlers;
+
+import org.eclipse.core.commands.*;
+import org.eclipse.pde.internal.runtime.spy.dialogs.LayoutSpyDialog;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+public class LayoutSpyHandler extends AbstractHandler {
+	private LayoutSpyDialog popupDialog;
+
+	@Override
+	public Object execute(ExecutionEvent event) throws ExecutionException {
+		if (popupDialog != null) {
+			popupDialog.close();
+		}
+
+		Shell shell = HandlerUtil.getActiveShell(event);
+		if (shell != null) {
+			popupDialog = new LayoutSpyDialog(shell);
+			popupDialog.open();
+		}
+		return null;
+	}
+
+}