diff --git a/src/main/java/com/simsilica/lemur/TabbedPanel.java b/src/main/java/com/simsilica/lemur/TabbedPanel.java
index 7b631da5..e4fad931 100644
--- a/src/main/java/com/simsilica/lemur/TabbedPanel.java
+++ b/src/main/java/com/simsilica/lemur/TabbedPanel.java
@@ -31,152 +31,153 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 package com.simsilica.lemur;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
 import com.jme3.math.ColorRGBA;
-
-import com.simsilica.lemur.core.VersionedHolder;
-import com.simsilica.lemur.core.VersionedObject;
-import com.simsilica.lemur.core.VersionedReference;
 import com.simsilica.lemur.component.BorderLayout;
 import com.simsilica.lemur.component.SpringGridLayout;
+import com.simsilica.lemur.component.VBoxLayout;
 import com.simsilica.lemur.core.GuiControl;
+import com.simsilica.lemur.core.VersionedHolder;
+import com.simsilica.lemur.core.VersionedObject;
+import com.simsilica.lemur.core.VersionedReference;
 import com.simsilica.lemur.style.ElementId;
 import com.simsilica.lemur.style.StyleAttribute;
 import com.simsilica.lemur.style.Styles;
-
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 /**
- *  A very simple tabbed panel element that presents a set
- *  of button "tabs" at the top that can select different child
- *  content.
+ * A very simple tabbed panel element that presents a set of button "tabs" at
+ * the top that can select different child content.
  *
- *  @author    Paul Speed
- */ 
+ * @author Paul Speed
+ */
 public class TabbedPanel extends Panel {
- 
+
     public static final ElementId ELEMENT_ID = new ElementId("tabbedPanel");
-    
-    private BorderLayout layout;
+
+    private VBoxLayout layout;
     private Container tabButtons;
     private Container container;
     private List<Tab> tabs = new ArrayList<Tab>();
-    
+
     private VersionedHolder<Tab> selectionModel = new VersionedHolder<>();
-    private VersionedReference<Tab> selectionRef = selectionModel.createReference();  
+    private VersionedReference<Tab> selectionRef = selectionModel.createReference();
     private Tab displayedTab;
-    
-    private ColorRGBA activationColor = ColorRGBA.Cyan;    
-    
+
+    private ColorRGBA activationColor = ColorRGBA.Cyan;
+
     public TabbedPanel() {
-        this(true, ELEMENT_ID, null);
+        this(true, ELEMENT_ID, null, VBoxLayout.HAlign.Left);
+    }
+
+    public TabbedPanel(VBoxLayout.HAlign TabBtnAlignment) {
+        this(true, ELEMENT_ID, null, TabBtnAlignment);
+    }
+
+    public TabbedPanel(String style) {
+        this(true, ELEMENT_ID, style, VBoxLayout.HAlign.Left);
+    }
+
+    public TabbedPanel(ElementId elementId, String style) {
+        this(true, elementId, style, VBoxLayout.HAlign.Left);
     }
 
-    public TabbedPanel( String style ) {
-        this(true, ELEMENT_ID, style);
+    public TabbedPanel(ElementId elementId, String style, VBoxLayout.HAlign TabBtnAlignment) {
+        this(true, elementId, style, TabBtnAlignment);
     }
-    
-    public TabbedPanel( ElementId elementId, String style ) {
-        this(true, elementId, style);
-    }  
- 
-    protected TabbedPanel( boolean applyStyles, ElementId elementId, String style )
-    {
+
+    protected TabbedPanel(boolean applyStyles, ElementId elementId, String style, VBoxLayout.HAlign TabBtnAlignment) {
         super(false, elementId, style);
 
-        this.layout = new BorderLayout();
+        this.layout = new VBoxLayout(0, FillMode.Last);
         getControl(GuiControl.class).setLayout(layout);
- 
+
         this.tabButtons = new Container(new SpringGridLayout(Axis.X, Axis.Y, FillMode.None, FillMode.Even),
-                                        elementId.child("tabButtons"), style);
-        layout.addChild(tabButtons, BorderLayout.Position.North);
- 
+                elementId.child("tabButtons"), style);
+        layout.addChild(tabButtons, TabBtnAlignment, false);
+
         this.container = new Container(new BorderLayout(), elementId.child("container"), style);
-        layout.addChild(container, BorderLayout.Position.Center);
- 
-        if( applyStyles ) {
+        layout.addChild(container, VBoxLayout.HAlign.Center, true);
+
+        if (applyStyles) {
             Styles styles = GuiGlobals.getInstance().getStyles();
             styles.applyStyles(this, elementId, style);
         }
     }
- 
+
     /**
-     *  Adds the specified contents as a new tab using the specified
-     *  title.
+     * Adds the specified contents as a new tab using the specified title.
      */
-    public <T extends Panel> T addTab( String title, T contents ) {
+    public <T extends Panel> T addTab(String title, T contents) {
         Tab tab = new Tab(title, contents);
         tabs.add(tab);
         refreshTabs();
-        if( selectionModel.getObject() == null ) {
+        if (selectionModel.getObject() == null) {
             setSelectedTab(tab);
         }
         return contents;
     }
 
     /**
-     *  Inserts the specified contents as a new tab using the specified
-     *  title inserted at the specified index.
+     * Inserts the specified contents as a new tab using the specified title
+     * inserted at the specified index.
      */
-    public <T extends Panel> T insertTab( int index, String title, T contents ) {
+    public <T extends Panel> T insertTab(int index, String title, T contents) {
         Tab tab = new Tab(title, contents);
         tabs.add(index, tab);
         refreshTabs();
-        if( selectionModel.getObject() == null ) {
+        if (selectionModel.getObject() == null) {
             setSelectedTab(tab);
         }
         return contents;
     }
- 
+
     /**
-     *  Removes the specified tab from this tabbed panel.  Returns
-     *  the tab that was removed or null if the tab is not a member
-     *  of this tabbed panel.
-     *  Note: if the specified tab is the currently selected tab
-     *  then the selection will be reset to the next available tab.
+     * Removes the specified tab from this tabbed panel. Returns the tab that
+     * was removed or null if the tab is not a member of this tabbed panel.
+     * Note: if the specified tab is the currently selected tab then the
+     * selection will be reset to the next available tab.
      */
-    public Tab removeTab( Tab tab ) {    
+    public Tab removeTab(Tab tab) {
         int index = tabs.indexOf(tab);
-        if( index < 0 ) {
+        if (index < 0) {
             return null;
         }
-        if( selectionModel.getObject() == tab ) {
+        if (selectionModel.getObject() == tab) {
             // Clear the current selection
             selectionModel.setObject(null);
         }
-        
+
         tabs.remove(tab);
         refreshTabs();
- 
+
         // See if we need to set the selection again
-        if( selectionModel.getObject() == null && !tabs.isEmpty() ) {
+        if (selectionModel.getObject() == null && !tabs.isEmpty()) {
             // Do the best we can
-            setSelectedTab(tabs.get(Math.min(index, tabs.size()-1)));
+            setSelectedTab(tabs.get(Math.min(index, tabs.size() - 1)));
         }
-        
+
         return tab;
     }
- 
+
     /**
-     *  Returns a read-only list of the Tabs contained in this tabbed panel.
+     * Returns a read-only list of the Tabs contained in this tabbed panel.
      */
     public List<Tab> getTabs() {
         return Collections.unmodifiableList(tabs);
     }
- 
-    /** 
-     *  Returns a versioned view of the currently selected tab.
-     *  Callers can create VersionedReferences to watch for changes.
+
+    /**
+     * Returns a versioned view of the currently selected tab. Callers can
+     * create VersionedReferences to watch for changes.
      */
     public VersionedObject<Tab> getSelectionModel() {
         return selectionModel;
     }
- 
+
     /*
     No reconfigurable selection model... at least for now.  There is no
     real 'model' class and VersionedObject has no setters (for good reason).
@@ -184,141 +185,139 @@ public void setSelectionModel( VersionedHolder<Tab> selectionModel ) {
         this.selectionModel = selectionModel;
         setSelectedTab(displayedTab);
     }*/
-    
- 
     /**
-     *  Sets the text color that will be used for activated tabs. 
+     * Sets the text color that will be used for activated tabs.
      */
-    @StyleAttribute(value="activationColor", lookupDefault=false)
-    public void setActivationColor( ColorRGBA color ) {
+    @StyleAttribute(value = "activationColor", lookupDefault = false)
+    public void setActivationColor(ColorRGBA color) {
         this.activationColor = color;
-        if( displayedTab != null ) {
+        if (displayedTab != null) {
             displayedTab.title.setColor(color);
-        }                
+        }
     }
- 
+
     /**
-     *  Returns the text color used for activated tabs.
-     */   
+     * Returns the text color used for activated tabs.
+     */
     public ColorRGBA getActivationColor() {
         return activationColor;
     }
-        
+
     protected void refreshTabs() {
         // Clean out any existing buttons
         tabButtons.getLayout().clearChildren();
-        
-        for( Tab tab : tabs ) {
+
+        for (Tab tab : tabs) {
             tabButtons.addChild(tab.title);
-        }       
+        }
     }
- 
+
     /**
-     *  Sets the currently selected tab to the tab specified.
+     * Sets the currently selected tab to the tab specified.
      */
-    public void setSelectedTab( Tab tab ) {
+    public void setSelectedTab(Tab tab) {
         // This should take care of ignoring nulls also
-        if( !tabs.contains(tab) ) {
+        if (!tabs.contains(tab)) {
             return;
         }
-        
+
         selectionModel.updateObject(tab);
-        
-        // Short-circuit just to make sure we change right away... no 
+
+        // Short-circuit just to make sure we change right away... no
         // reason to wait until the next frame in this case.
         setDisplayedTab(selectionModel.getObject());
     }
- 
+
     /**
-     *  Returns the currently selected tab.
-     */   
+     * Returns the currently selected tab.
+     */
     public Tab getSelectedTab() {
         return selectionModel.getObject();
     }
-    
-    protected void setDisplayedTab( Tab tab ) {
-        if( displayedTab == tab ) {
+
+    protected void setDisplayedTab(Tab tab) {
+        if (displayedTab == tab) {
             // Already displaying it
             return;
         }
-        if( displayedTab != null ) {
+        if (displayedTab != null) {
             displayedTab.removeContents();
         }
         displayedTab = tab;
-        if( displayedTab != null ) {
+        if (displayedTab != null) {
             displayedTab.addContents();
         }
-        for( Tab t : tabs ) {
+        for (Tab t : tabs) {
             t.title.setChecked(t == tab);
-        }        
+        }
     }
- 
+
     @Override
-    public void updateLogicalState( float tpf ) {
+    public void updateLogicalState(float tpf) {
         super.updateLogicalState(tpf);
 
-        if( selectionRef != null && selectionRef.update() ) {
+        if (selectionRef != null && selectionRef.update()) {
             setDisplayedTab(selectionRef.get());
         }
     }
- 
+
     /**
-     *  Represents a Tab in the TabbedPanel.
-     */   
+     * Represents a Tab in the TabbedPanel.
+     */
     public class Tab {
         private Checkbox title;
         private Panel contents;
         private ColorRGBA originalColor;
 
-        @SuppressWarnings("unchecked") // because Java doesn't like var-arg generics        
-        public Tab( String title, Panel contents ) {
+        @SuppressWarnings("unchecked") // because Java doesn't like var-arg generics
+        public Tab(String title, Panel contents) {
             this.title = new Checkbox(title, getElementId().child("tab.button"), getStyle());
             this.title.addClickCommands(new SwitchToTab(this));
             this.contents = contents;
         }
-        
+
         public String getTitle() {
             return title.getText();
         }
-        
+
         public Checkbox getTitleButton() {
             return title;
         }
-        
+
         public Panel getContents() {
             return contents;
         }
-        
+
         protected void removeContents() {
-            if( contents == null ) {
+            if (contents == null) {
                 return;
             }
-            if( contents.getParent() != null ) {
+            if (contents.getParent() != null) {
                 container.removeChild(contents);
                 title.setColor(originalColor);
             }
         }
-        
+
         protected void addContents() {
-            if( contents == null ) {
+            if (contents == null) {
                 return;
             }
-            if( contents.getParent() == null ) {
+            if (contents.getParent() == null) {
                 container.addChild(contents, BorderLayout.Position.Center);
                 originalColor = title.getColor();
                 title.setColor(activationColor);
-            }            
+            }
         }
     }
-    
+
     protected class SwitchToTab implements Command<Button> {
         private Tab tab;
-        
-        public SwitchToTab( Tab tab ) {
+
+        public SwitchToTab(Tab tab) {
             this.tab = tab;
         }
 
-        public void execute( Button source ) {
+        public void execute(Button source) {
             setSelectedTab(tab);
         }
     }
diff --git a/src/main/java/com/simsilica/lemur/component/HBoxLayout.java b/src/main/java/com/simsilica/lemur/component/HBoxLayout.java
new file mode 100644
index 00000000..02c7970c
--- /dev/null
+++ b/src/main/java/com/simsilica/lemur/component/HBoxLayout.java
@@ -0,0 +1,577 @@
+/*
+ * Feel free to use, modify, and/or distribute this source code for personal,
+ * educational, commercial or any other reason you may conceive with or
+ * without credit. There are absolutely no restrictions on the use,
+ * modification or distribution of this code.
+ */
+package com.simsilica.lemur.component;
+
+import com.jme3.math.Vector3f;
+import com.jme3.scene.Node;
+import com.simsilica.lemur.FillMode;
+import com.simsilica.lemur.core.GuiControl;
+import com.simsilica.lemur.core.GuiLayout;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * A layout similar to the JavaFX HBox in which children are laid out
+ * horizontally in the order they were added with optional spacing between each
+ * child. An optional <code>FillMode</code> can be supplied to indicate how to
+ * treat resizing the child elements horizontally when the HBoxLayout is bigger
+ * or smaller than the sum of its children.
+ *
+ * None - Children will not be resized horizontally, extra space is empty. This
+ * defaults to Proportional when children need to shrink. Even - Remaining space
+ * is divided evenly among the children or the children are shrunk by equal
+ * amounts. Proportional - Children are grown or shrunken by an amount
+ * proportional to their original size. ForcedEven - The space in the HBoxLayout
+ * is divided evenly among all children. First - The first child takes up all of
+ * the remaining space, if the children need to shrink the first child absorbs
+ * all of the shrinkage, if additional shrinkage is required the next child will
+ * shrink and so on. Last - Same as First, except we start enlarging or
+ * shrinking from the bottom.
+ *
+ * Child elements can be instructed to fill remaining vertical space or, by
+ * default, remain their original vertical size. By default items that do not
+ * fill the vertical size of the HBoxLayout will be aligned to the top, the
+ * default alignment can be changed in the constructor and overridden by each
+ * added child. Additional alignments are Bottom and Center.
+ *
+ * @author Adam T. Ryder http://1337atr.weebly.com
+ */
+public class HBoxLayout extends AbstractGuiComponent implements GuiLayout, Cloneable {
+
+    public enum VAlign {
+        Top,
+        Center,
+        Bottom
+    }
+
+    private GuiControl parent;
+    private List<Entry> children = new LinkedList<Entry>();
+
+    private float margin;
+    private FillMode fillMode;
+    private boolean fillHeight = false;
+
+    private VAlign defaultAlign;
+
+    /**
+     * Constructs a new <code>HBoxLayout</code> with no spacing between
+     * elements, <code>FillMode.None</code>, elements will not stretch to fill
+     * remaining vertical space and are top aligned.
+     */
+    public HBoxLayout() {
+        this(0);
+    }
+
+    /**
+     * Constructs a new <code>HBoxLayout</code> with <code>FillMode.None</code>,
+     * elements will not stretch to fill remaining vertical space and are top
+     * aligned.
+     *
+     * @param margin Amount of space between elements.
+     */
+    public HBoxLayout(float margin) {
+        this(margin, FillMode.None);
+    }
+
+    /**
+     * Constructs a new <code>HBoxLayout</code> elements will not stretch to
+     * fill remaining vertical space and are top aligned.
+     *
+     * @param margin Amount of space between elements.
+     * @param vFillMode <code>FillMode</code> indicating how horizontal
+     * stretching and shrinking should work.
+     */
+    public HBoxLayout(float margin, FillMode vFillMode) {
+        this(margin, vFillMode, false);
+    }
+
+    /**
+     * Constructs a new <code>HBoxLayout</code> elements are top aligned.
+     *
+     * @param margin Amount of space between elements.
+     * @param vFillMode <code>FillMode</code> indicating how horizontal
+     * stretching and shrinking should work.
+     * @param fillHeight <code>true</code> elements smaller than the height of
+     * the <code>HBoxLayout</code> will be stretched to fill the height,
+     * otherwise they remain their original size. This can be overridden by
+     * individual elements when they are added.
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.HBoxLayout.VAlign, boolean)
+     */
+    public HBoxLayout(float margin, FillMode vFillMode, boolean fillHeight) {
+        this(margin, vFillMode, fillHeight, VAlign.Top);
+    }
+
+    /**
+     * Constructs a new <code>HBoxLayout</code>.
+     *
+     * @param margin Amount of space between elements.
+     * @param vFillMode <code>FillMode</code> indicating how horizontal
+     * stretching and shrinking should work.
+     * @param fillHeight <code>true</code> elements smaller than the height of
+     * the <code>HBoxLayout</code> will be stretched to fill the height,
+     * otherwise they remain their original size. This value can be overridden
+     * by individual elements when they are added.
+     * @param defaultAlignment Elements are aligned horizontally either Left,
+     * Right or Center. This can be overridden when adding an element.
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.HBoxLayout.VAlign, boolean)
+     * @see VAlign
+     */
+    public HBoxLayout(float margin, FillMode vFillMode, boolean fillHeight, VAlign defaultAlignment) {
+        this.margin = margin;
+        this.fillMode = vFillMode;
+        this.fillHeight = fillHeight;
+        defaultAlign = defaultAlignment;
+    }
+
+    /**
+     * Set the amount of space between elements.
+     *
+     * @param margin The amount of space between elements.
+     */
+    public void setMargin(float margin) {
+        this.margin = margin;
+        invalidate();
+    }
+
+    /**
+     * Gets the amount of space between elements.
+     *
+     * @return The current amount of space between elements.
+     */
+    public float getMargin() {
+        return margin;
+    }
+
+    /**
+     * Sets the method by which child elements will be grown or shrunk
+     * horizontally when the <code>HBoxLayout</code> is bigger or smaller than
+     * the sum of element heights.
+     *
+     * None - Children will not be resized horizontally, extra space is empty.
+     * This defaults to Proportional when children need to shrink. Even -
+     * Remaining space is divided evenly among the children or the children are
+     * shrunk by equal amounts. Proportional - Children are grown or shrunken by
+     * an amount proportional to their original size. ForcedEven - The space in
+     * the HBoxLayout is divided evenly among all children. First - The first
+     * child takes up all of the remaining space, if the children need to shrink
+     * the first child absorbs all of the shrinkage, if additional shrinkage is
+     * required the next child will shrink and so on. Last - Same as First,
+     * except we start enlarging or shrinking from the bottom.
+     *
+     * @param fMode
+     */
+    public void setFillMode(FillMode fMode) {
+        fillMode = fMode;
+        invalidate();
+    }
+
+    public FillMode getFillMode() {
+        return fillMode;
+    }
+
+    /**
+     * Whether or not elements that do not fill the whole height of the
+     * <code>HBoxLayout</code> should be stretched to fill the height by
+     * default.
+     *
+     * @param fillHeight If true elements will be stretched to fill the full
+     * height of the <code>HBoxLayout</code>.
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.HBoxLayout.VAlign, boolean)
+     */
+    public void setFillHeight(boolean fillHeight) {
+        this.fillHeight = fillHeight;
+        invalidate();
+    }
+
+    /**
+     * Whether or not elements that do not fill the whole height of the
+     * <code>HBoxLayout</code> should be stretched to fill the height by
+     * default.
+     *
+     * @return The current height filling state.
+     */
+    public boolean isFillHeight() {
+        return fillHeight;
+    }
+
+    @Override
+    public void calculatePreferredSize(Vector3f size) {
+        if (children.isEmpty()) {
+            return;
+        }
+
+        float maxY = 0;
+        float maxZ = 0;
+        float xSize = 0;
+        for (Entry e : children) {
+            Vector3f v = e.entry.getControl(GuiControl.class).getPreferredSize();
+            e.size = v;
+            xSize += v.x + margin;
+
+            if (maxY < v.y) {
+                maxY = v.y;
+            }
+            if (maxZ < v.z) {
+                maxZ = v.z;
+            }
+        }
+
+        if (xSize > 0) {
+            xSize -= margin;
+        }
+
+        size.set(xSize, maxY, maxZ);
+    }
+
+    @Override
+    public void reshape(Vector3f pos, Vector3f size) {
+        calculatePreferredSize(new Vector3f());
+
+        float preferredWidth = 0;
+        for (Entry e : children) {
+            preferredWidth += e.size.x + margin;
+        }
+        if (preferredWidth > 0) {
+            preferredWidth -= margin;
+        }
+
+        if (fillMode == FillMode.ForcedEven) {
+            float amount = margin * (children.size() - 1);
+            amount = (size.x - amount) / children.size();
+            if (amount < 0) {
+                amount = 0;
+            }
+            for (Entry e : children) {
+                e.size.x = amount;
+            }
+        } else if (preferredWidth < size.x) {
+            growChildren(preferredWidth, size.x);
+        } else if (preferredWidth > size.x) {
+            shrinkChildren(preferredWidth, size.x);
+        }
+
+        Vector3f p = pos.clone();
+        List<Entry> toRemove = new LinkedList<Entry>();
+        List<Entry> toAdd = new LinkedList<Entry>();
+        for (Entry e : children) {
+            if (e.size.x > 0) {
+                if (e.entry.getParent() == null) {
+                    toAdd.add(e);
+                }
+            } else {
+                if (e.entry.getParent() != null) {
+                    toRemove.add(e);
+                }
+                continue;
+            }
+
+            Vector3f pref = e.size;
+            pref.y = (size.y > pref.y && !e.fillHeight) ? pref.y : size.y;
+
+            if (pref.y != size.y) {
+                switch (e.align) {
+                    case Center:
+                        p.y = pos.y - ((size.y / 2) - (pref.y / 2));
+                        break;
+                    case Bottom:
+                        p.y = pos.y - (size.y - pref.y);
+                        break;
+                    default:
+                        p.y = pos.y;
+                }
+            }
+
+            e.entry.setLocalTranslation(p.clone());
+            p.x += pref.x + margin;
+
+            e.entry.getControl(GuiControl.class).setSize(new Vector3f(pref.x, pref.y, pref.z));
+            p.y = pos.y;
+        }
+
+        if (!toAdd.isEmpty()) {
+            for (Entry e : toAdd) {
+                parent.getNode().attachChild(e.entry);
+            }
+        }
+        if (!toRemove.isEmpty()) {
+            for (Entry e : toAdd) {
+                int i = children.indexOf(e);
+                children.remove(i);
+                e.entry.getParent().detachChild(e.entry);
+                children.add(i, e);
+            }
+        }
+    }
+
+    private void shrinkChildren(float requestWidth, float actualWidth) {
+        float amount;
+
+        //Can't deal with FillMode.None, we have to shrink
+        FillMode fMode = fillMode == FillMode.None ? FillMode.Even : fillMode;
+
+        switch (fMode) {
+            case Even:
+                //Evenly distribute extra size among the children
+                amount = (requestWidth - actualWidth) / children.size();
+                for (Entry e : children) {
+                    e.size.x -= amount;
+                    if (e.size.x < 0) {
+                        e.size.x = 0;
+                    }
+                }
+                break;
+            case Proportional:
+                //Grow children proportionally
+                amount = requestWidth - actualWidth;
+                requestWidth -= margin * (children.size() - 1);
+                for (Entry e : children) {
+                    e.size.x -= amount * (e.size.x / requestWidth);
+                    if (e.size.x < 0) {
+                        e.size.x = 0;
+                    }
+                }
+                break;
+            case First:
+                //First child takes up all the extra space
+                amount = requestWidth - actualWidth;
+                int current = 0;
+                do {
+                    Entry e = children.get(current);
+                    float orig = e.size.x;
+                    e.size.x -= amount;
+                    if (e.size.x < 0) {
+                        e.size.x = 0;
+                        amount -= orig;
+                        current++;
+                    } else {
+                        break;
+                    }
+                } while (current < children.size() && amount > 0);
+                break;
+            case Last:
+                //Last child takes up all the extra space
+                amount = requestWidth - actualWidth;
+                int currentL = children.size() - 1;
+                do {
+                    Entry e = children.get(currentL);
+                    float orig = e.size.x;
+                    e.size.x -= amount;
+                    if (e.size.x < 0) {
+                        e.size.x = 0;
+                        amount -= orig;
+                        currentL--;
+                    } else {
+                        break;
+                    }
+                } while (currentL >= 0 && amount > 0);
+                break;
+        }
+    }
+
+    private void growChildren(float requestWidth, float actualWidth) {
+        float amount;
+        switch (fillMode) {
+            case None:
+                //Do nothing
+                break;
+            case Even:
+                //Evenly distribute extra size amont the children
+                amount = (actualWidth - requestWidth) / children.size();
+                for (Entry e : children) {
+                    e.size.x += amount;
+                }
+                break;
+            case Proportional:
+                //Grow children proportionally
+                amount = actualWidth - requestWidth;
+                requestWidth -= margin * (children.size() - 1);
+                for (Entry e : children) {
+                    e.size.x += amount * (e.size.x / requestWidth);
+                }
+                break;
+            case First:
+                //First child takes up all the extra space
+                amount = actualWidth - requestWidth;
+                children.get(0).size.x += amount;
+                break;
+            case Last:
+                //Last child takes up all the extra space
+                amount = actualWidth - requestWidth;
+                children.get(children.size() - 1).size.x += amount;
+                break;
+        }
+    }
+
+    @Override
+    protected void invalidate() {
+        if (parent != null) {
+            parent.invalidate();
+        }
+    }
+
+    /**
+     * Adds a child element to this layout.
+     *
+     * @param <T> The type of the child to add such as <code>Panel</code>
+     * @param n The child to add.
+     * @param alignment The type of horizontal alignment to use.
+     * @param fillHeight True if this element should fill remaining vertical
+     * space.
+     * @return The child that was added.
+     *
+     * @see VAlign
+     */
+    public <T extends Node> T addChild(T n, VAlign alignment, boolean fillHeight) {
+        Entry entry = new Entry(n, alignment, fillHeight);
+        children.add(entry);
+
+        if (parent != null) {
+            parent.getNode().attachChild(n);
+        }
+
+        invalidate();
+
+        return n;
+    }
+
+    /**
+     *
+     * @param <T>
+     * @param n
+     * @param constraints
+     * @return
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.HBoxLayout.VAlign, boolean)
+     */
+    @Override
+    public <T extends Node> T addChild(T n, Object... constraints) {
+        if (n.getControl(GuiControl.class) == null) {
+            throw new IllegalArgumentException("Child is not GUI element.");
+        }
+
+        if (constraints.length > 1) {
+            if ((constraints[0] instanceof VAlign) && (constraints[1] instanceof Boolean)) {
+                addChild(n, (VAlign) constraints[0], (Boolean) constraints[1]);
+                return n;
+            } else if ((constraints[0] instanceof Boolean) && (constraints[1] instanceof VAlign)) {
+                addChild(n, (VAlign) constraints[1], (Boolean) constraints[0]);
+                return n;
+            } else {
+                throw new IllegalArgumentException("Unknown VBoxLayout constraint:" + constraints[0]
+                        + " : " + constraints[1]);
+            }
+        }
+
+        if (constraints.length > 0) {
+            if (constraints[0] instanceof VAlign) {
+                addChild(n, (VAlign) constraints[0], fillHeight);
+                return n;
+            } else if (constraints[0] instanceof Boolean) {
+                addChild(n, defaultAlign, (Boolean) constraints[0]);
+                return n;
+            } else {
+                throw new IllegalArgumentException("Unknown VBoxLayout constraint:" + constraints[0]);
+            }
+        }
+
+        addChild(n, defaultAlign, fillHeight);
+
+        return n;
+    }
+
+    @Override
+    public void removeChild(Node n) {
+        for (Entry e : children) {
+            if (e.entry.equals(n)) {
+                children.remove(e);
+                if (parent != null) {
+                    parent.getNode().detachChild(n);
+                }
+                break;
+            }
+        }
+
+        invalidate();
+    }
+
+    @Override
+    public List<Node> getChildren() {
+        ArrayList<Node> list = new ArrayList<Node>(children.size());
+        for (Entry e : children) {
+            list.add(e.entry);
+        }
+
+        return list;
+    }
+
+    @Override
+    public void clearChildren() {
+        if (parent != null) {
+            Collection<Entry> copy = new LinkedList<Entry>(children);
+            for (Entry e : copy) {
+                parent.getNode().detachChild(e.entry);
+            }
+        }
+
+        children.clear();
+        invalidate();
+    }
+
+    @Override
+    public void attach(GuiControl parent) {
+        this.parent = parent;
+        Node self = parent.getNode();
+        for (Entry e : children) {
+            self.attachChild(e.entry);
+        }
+    }
+
+    @Override
+    public void detach(GuiControl parent) {
+        this.parent = null;
+        Collection<Entry> copy = new LinkedList<Entry>(children);
+        for (Entry e : copy) {
+            e.entry.removeFromParent();
+        }
+    }
+
+    @Override
+    public HBoxLayout clone() {
+        HBoxLayout result = (HBoxLayout) super.clone();
+        result.parent = null;
+        result.children = new LinkedList<Entry>(children);
+        result.margin = margin;
+        result.fillMode = fillMode;
+        result.fillHeight = fillHeight;
+        result.defaultAlign = defaultAlign;
+
+        return result;
+    }
+
+    private class Entry {
+
+        public final Node entry;
+        public final VAlign align;
+        public final boolean fillHeight;
+        public Vector3f size = new Vector3f();
+
+        private Entry(Node entry, VAlign align, boolean fillHeight) {
+            this.entry = entry;
+            this.align = align;
+            this.fillHeight = fillHeight;
+        }
+    }
+}
diff --git a/src/main/java/com/simsilica/lemur/component/VBoxLayout.java b/src/main/java/com/simsilica/lemur/component/VBoxLayout.java
new file mode 100644
index 00000000..48d83c82
--- /dev/null
+++ b/src/main/java/com/simsilica/lemur/component/VBoxLayout.java
@@ -0,0 +1,577 @@
+/*
+ * Feel free to use, modify, and/or distribute this source code for personal,
+ * educational, commercial or any other reason you may conceive with or
+ * without credit. There are absolutely no restrictions on the use,
+ * modification or distribution of this code.
+ */
+package com.simsilica.lemur.component;
+
+import com.jme3.math.Vector3f;
+import com.jme3.scene.Node;
+import com.simsilica.lemur.FillMode;
+import com.simsilica.lemur.core.GuiControl;
+import com.simsilica.lemur.core.GuiLayout;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * A layout similar to the JavaFX VBox in which children are laid out vertically
+ * in the order they were added with optional spacing between each child. An
+ * optional <code>FillMode</code> can be supplied to indicate how to treat
+ * resizing the child elements vertically when the VBoxLayout is bigger or
+ * smaller than the sum of its children.
+ *
+ * None - Children will not be resized vertically, extra space is empty. This
+ * defaults to Proportional when children need to shrink. Even - Remaining space
+ * is divided evenly among the children or the children are shrunk by equal
+ * amounts. Proportional - Children are grown or shrunken by an amount
+ * proportional to their original size. ForcedEven - The space in the VBoxLayout
+ * is divided evenly among all children. First - The first child takes up all of
+ * the remaining space, if the children need to shrink the first child absorbs
+ * all of the shrinkage, if additional shrinkage is required the next child will
+ * shrink and so on. Last - Same as First, except we start enlarging or
+ * shrinking from the bottom.
+ *
+ * Child elements can be instructed to fill remaining horizontal space or, by
+ * default, remain their original horizontal size. By default items that do not
+ * fill the horizontal size of the VBoxLayout will be aligned to the left, the
+ * default alignment can be changed in the constructor and overridden by each
+ * added child. Additional alignments are Right and Center.
+ *
+ * @author Adam T. Ryder http://1337atr.weebly.com
+ */
+public class VBoxLayout extends AbstractGuiComponent implements GuiLayout, Cloneable {
+
+    public enum HAlign {
+        Left,
+        Center,
+        Right
+    }
+
+    private GuiControl parent;
+    private List<Entry> children = new LinkedList<Entry>();
+
+    private float margin;
+    private FillMode fillMode;
+    private boolean fillWidth = false;
+
+    private HAlign defaultAlign;
+
+    /**
+     * Constructs a new <code>VBoxLayout</code> with no spacing between
+     * elements, <code>FillMode.None</code>, elements will not stretch to fill
+     * remaining horizontal space and are left aligned.
+     */
+    public VBoxLayout() {
+        this(0);
+    }
+
+    /**
+     * Constructs a new <code>VBoxLayout</code> with <code>FillMode.None</code>,
+     * elements will not stretch to fill remaining horizontal space and are left
+     * aligned.
+     *
+     * @param margin Amount of space between elements.
+     */
+    public VBoxLayout(float margin) {
+        this(margin, FillMode.None);
+    }
+
+    /**
+     * Constructs a new <code>VBoxLayout</code> elements will not stretch to
+     * fill remaining horizontal space and are left aligned.
+     *
+     * @param margin Amount of space between elements.
+     * @param vFillMode <code>FillMode</code> indicating how vertical stretching
+     * and shrinking should work.
+     */
+    public VBoxLayout(float margin, FillMode vFillMode) {
+        this(margin, vFillMode, false);
+    }
+
+    /**
+     * Constructs a new <code>VBoxLayout</code> elements are left aligned.
+     *
+     * @param margin Amount of space between elements.
+     * @param vFillMode <code>FillMode</code> indicating how vertical stretching
+     * and shrinking should work.
+     * @param fillWidth <code>true</code> elements smaller than the width of the
+     * <code>VBoxLayout</code> will be stretched to fill the width, otherwise
+     * they remain their original size. This can be overridden by individual
+     * elements when they are added.
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.VBoxLayout.HAlign, boolean)
+     */
+    public VBoxLayout(float margin, FillMode vFillMode, boolean fillWidth) {
+        this(margin, vFillMode, fillWidth, HAlign.Left);
+    }
+
+    /**
+     * Constructs a new <code>VBoxLayout</code>.
+     *
+     * @param margin Amount of space between elements.
+     * @param vFillMode <code>FillMode</code> indicating how vertical stretching
+     * and shrinking should work.
+     * @param fillWidth <code>true</code> elements smaller than the width of the
+     * <code>VBoxLayout</code> will be stretched to fill the width, otherwise
+     * they remain their original size. This can be overridden by individual
+     * elements when they are added.
+     * @param defaultAlignment Elements are aligned horizontally either Left,
+     * Right or Center. This can be overridden when adding an element.
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.VBoxLayout.HAlign, boolean)
+     * @see HAlign
+     */
+    public VBoxLayout(float margin, FillMode vFillMode, boolean fillWidth, HAlign defaultAlignment) {
+        this.margin = margin;
+        this.fillMode = vFillMode;
+        this.fillWidth = fillWidth;
+        defaultAlign = defaultAlignment;
+    }
+
+    /**
+     * Set the amount of space between elements.
+     *
+     * @param margin The amount of space between elements.
+     */
+    public void setMargin(float margin) {
+        this.margin = margin;
+        invalidate();
+    }
+
+    /**
+     * Gets the amount of space between elements.
+     *
+     * @return The current amount of space between elements.
+     */
+    public float getMargin() {
+        return margin;
+    }
+
+    /**
+     * Sets the method by which child elements will be grown or shrunk
+     * vertically when the <code>VBoxLayout</code> is bigger or smaller than the
+     * sum of element heights.
+     *
+     * None - Children will not be resized vertically, extra space is empty.
+     * This defaults to Proportional when children need to shrink. Even -
+     * Remaining space is divided evenly among the children or the children are
+     * shrunk by equal amounts. Proportional - Children are grown or shrunken by
+     * an amount proportional to their original size. ForcedEven - The space in
+     * the VBoxLayout is divided evenly among all children. First - The first
+     * child takes up all of the remaining space, if the children need to shrink
+     * the first child absorbs all of the shrinkage, if additional shrinkage is
+     * required the next child will shrink and so on. Last - Same as First,
+     * except we start enlarging or shrinking from the bottom.
+     *
+     * @param fMode
+     */
+    public void setFillMode(FillMode fMode) {
+        fillMode = fMode;
+        invalidate();
+    }
+
+    public FillMode getFillMode() {
+        return fillMode;
+    }
+
+    /**
+     * Whether or not elements that do not fill the whole width of the
+     * <code>VBoxLayout</code> should be stretched to fill the width by default.
+     * This can be overridden when adding elements.
+     *
+     * @param fillWidth If true elements will be stretched to fill the full
+     * width of the <code>VBoxLayout</code>.
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.VBoxLayout.HAlign, boolean)
+     */
+    public void setFillWidth(boolean fillWidth) {
+        this.fillWidth = fillWidth;
+        invalidate();
+    }
+
+    /**
+     * Whether or not elements that do not fill the whole width of the
+     * <code>VBoxLayout</code> should be stretched to fill the width by default.
+     *
+     * @return The current width filling state.
+     */
+    public boolean isFillWidth() {
+        return fillWidth;
+    }
+
+    @Override
+    public void calculatePreferredSize(Vector3f size) {
+        if (children.isEmpty()) {
+            return;
+        }
+
+        float maxX = 0;
+        float maxZ = 0;
+        float ySize = 0;
+        for (Entry e : children) {
+            Vector3f v = e.entry.getControl(GuiControl.class).getPreferredSize();
+            e.size = v;
+            ySize += v.y + margin;
+
+            if (maxX < v.x) {
+                maxX = v.x;
+            }
+            if (maxZ < v.z) {
+                maxZ = v.z;
+            }
+        }
+
+        if (ySize > 0) {
+            ySize -= margin;
+        }
+
+        size.set(maxX, ySize, maxZ);
+    }
+
+    @Override
+    public void reshape(Vector3f pos, Vector3f size) {
+        calculatePreferredSize(new Vector3f());
+
+        float preferredHeight = 0;
+        for (Entry e : children) {
+            preferredHeight += e.size.y + margin;
+        }
+        if (preferredHeight > 0) {
+            preferredHeight -= margin;
+        }
+
+        if (fillMode == FillMode.ForcedEven) {
+            float amount = margin * (children.size() - 1);
+            amount = (size.y - amount) / children.size();
+            if (amount < 0) {
+                amount = 0;
+            }
+            for (Entry e : children) {
+                e.size.y = amount;
+            }
+        } else if (preferredHeight < size.y) {
+            growChildren(preferredHeight, size.y);
+        } else if (preferredHeight > size.y) {
+            shrinkChildren(preferredHeight, size.y);
+        }
+
+        Vector3f p = pos.clone();
+
+        List<Entry> toRemove = new LinkedList<Entry>();
+        List<Entry> toAdd = new LinkedList<Entry>();
+        for (Entry e : children) {
+            if (e.size.y > 0) {
+                if (e.entry.getParent() == null) {
+                    toAdd.add(e);
+                }
+            } else {
+                if (e.entry.getParent() != null) {
+                    toRemove.add(e);
+                }
+                continue;
+            }
+
+            Vector3f pref = e.size;
+            pref.x = (size.x > pref.x && !e.fillWidth) ? pref.x : size.x;
+
+            if (pref.x != size.x) {
+                switch (e.align) {
+                    case Center:
+                        p.x = pos.x + ((size.x / 2) - (pref.x / 2));
+                        break;
+                    case Right:
+                        p.x = pos.x + (size.x - pref.x);
+                        break;
+                    default:
+                        p.x = pos.x;
+                }
+            }
+
+            e.entry.setLocalTranslation(p.clone());
+            p.y -= pref.y + margin;
+
+            e.entry.getControl(GuiControl.class).setSize(new Vector3f(pref.x, pref.y, pref.z));
+            p.x = pos.x;
+        }
+
+        if (!toAdd.isEmpty()) {
+            for (Entry e : toAdd) {
+                parent.getNode().attachChild(e.entry);
+            }
+        }
+        if (!toRemove.isEmpty()) {
+            for (Entry e : toAdd) {
+                int i = children.indexOf(e);
+                children.remove(i);
+                e.entry.getParent().detachChild(e.entry);
+                children.add(i, e);
+            }
+        }
+    }
+
+    private void shrinkChildren(float requestHeight, float actualHeight) {
+        float amount;
+
+        //Can't deal with FillMode.None, we have to shrink
+        FillMode fMode = fillMode == FillMode.None ? FillMode.Even : fillMode;
+
+        switch (fMode) {
+            case Even:
+                //Evenly distribute extra size among the children
+                amount = (requestHeight - actualHeight) / children.size();
+                for (Entry e : children) {
+                    e.size.y -= amount;
+                    if (e.size.y < 0) {
+                        e.size.y = 0;
+                    }
+                }
+                break;
+            case Proportional:
+                //Grow children proportionally
+                amount = requestHeight - actualHeight;
+                requestHeight -= margin * (children.size() - 1);
+                for (Entry e : children) {
+                    e.size.y -= amount * (e.size.y / requestHeight);
+                    if (e.size.y < 0) {
+                        e.size.y = 0;
+                    }
+                }
+                break;
+            case First:
+                //First child takes up all the extra space
+                amount = requestHeight - actualHeight;
+                int current = 0;
+                do {
+                    Entry e = children.get(current);
+                    float orig = e.size.y;
+                    e.size.y -= amount;
+                    if (e.size.y < 0) {
+                        e.size.y = 0;
+                        amount -= orig;
+                        current++;
+                    } else {
+                        break;
+                    }
+                } while (current < children.size() && amount > 0);
+                break;
+            case Last:
+                //Last child takes up all the extra space
+                amount = requestHeight - actualHeight;
+                int currentL = children.size() - 1;
+                do {
+                    Entry e = children.get(currentL);
+                    float orig = e.size.y;
+                    e.size.y -= amount;
+                    if (e.size.y < 0) {
+                        e.size.y = 0;
+                        amount -= orig;
+                        currentL--;
+                    } else {
+                        break;
+                    }
+                } while (currentL >= 0 && amount > 0);
+                break;
+        }
+    }
+
+    private void growChildren(float requestHeight, float actualHeight) {
+        float amount;
+        switch (fillMode) {
+            case None:
+                //Do nothing
+                break;
+            case Even:
+                //Evenly distribute extra size amont the children
+                amount = (actualHeight - requestHeight) / children.size();
+                for (Entry e : children) {
+                    e.size.y += amount;
+                }
+                break;
+            case Proportional:
+                //Grow children proportionally
+                amount = actualHeight - requestHeight;
+                requestHeight -= margin * (children.size() - 1);
+                for (Entry e : children) {
+                    e.size.y += amount * (e.size.y / requestHeight);
+                }
+                break;
+            case First:
+                //First child takes up all the extra space
+                amount = actualHeight - requestHeight;
+                children.get(0).size.y += amount;
+                break;
+            case Last:
+                //Last child takes up all the extra space
+                amount = actualHeight - requestHeight;
+                children.get(children.size() - 1).size.y += amount;
+                break;
+        }
+    }
+
+    @Override
+    protected void invalidate() {
+        if (parent != null) {
+            parent.invalidate();
+        }
+    }
+
+    /**
+     * Adds a child element to this layout.
+     *
+     * @param <T> The type of the child to add such as <code>Panel</code>
+     * @param n The child to add.
+     * @param alignment The type of horizontal alignment to use.
+     * @param fillWidth True if this element should fill remaining horizontal
+     * space.
+     * @return The child that was added.
+     *
+     * @see HAlign
+     */
+    public <T extends Node> T addChild(T n, HAlign alignment, boolean fillWidth) {
+        Entry entry = new Entry(n, alignment, fillWidth);
+        children.add(entry);
+
+        if (parent != null) {
+            parent.getNode().attachChild(n);
+        }
+
+        invalidate();
+
+        return n;
+    }
+
+    /**
+     *
+     * @param <T>
+     * @param n
+     * @param constraints
+     * @return
+     *
+     * @see #addChild(com.jme3.scene.Node,
+     * chet2.ui.components.VBoxLayout.HAlign, boolean)
+     */
+    @Override
+    public <T extends Node> T addChild(T n, Object... constraints) {
+        if (n.getControl(GuiControl.class) == null) {
+            throw new IllegalArgumentException("Child is not GUI element.");
+        }
+
+        if (constraints.length > 1) {
+            if ((constraints[0] instanceof HAlign) && (constraints[1] instanceof Boolean)) {
+                addChild(n, (HAlign) constraints[0], (Boolean) constraints[1]);
+                return n;
+            } else if ((constraints[0] instanceof Boolean) && (constraints[1] instanceof HAlign)) {
+                addChild(n, (HAlign) constraints[1], (Boolean) constraints[0]);
+                return n;
+            } else {
+                throw new IllegalArgumentException("Unknown VBoxLayout constraint:" + constraints[0]
+                        + " : " + constraints[1]);
+            }
+        }
+
+        if (constraints.length > 0) {
+            if (constraints[0] instanceof HAlign) {
+                addChild(n, (HAlign) constraints[0], fillWidth);
+                return n;
+            } else if (constraints[0] instanceof Boolean) {
+                addChild(n, defaultAlign, (Boolean) constraints[0]);
+                return n;
+            } else {
+                throw new IllegalArgumentException("Unknown VBoxLayout constraint:" + constraints[0]);
+            }
+        }
+
+        addChild(n, defaultAlign, fillWidth);
+
+        return n;
+    }
+
+    @Override
+    public void removeChild(Node n) {
+        for (Entry e : children) {
+            if (e.entry.equals(n)) {
+                children.remove(e);
+                if (parent != null) {
+                    parent.getNode().detachChild(n);
+                }
+                break;
+            }
+        }
+
+        invalidate();
+    }
+
+    @Override
+    public List<Node> getChildren() {
+        ArrayList<Node> list = new ArrayList<Node>(children.size());
+        for (Entry e : children) {
+            list.add(e.entry);
+        }
+
+        return list;
+    }
+
+    @Override
+    public void clearChildren() {
+        if (parent != null) {
+            Collection<Entry> copy = new LinkedList<Entry>(children);
+            for (Entry e : copy) {
+                parent.getNode().detachChild(e.entry);
+            }
+        }
+
+        children.clear();
+        invalidate();
+    }
+
+    @Override
+    public void attach(GuiControl parent) {
+        this.parent = parent;
+        Node self = parent.getNode();
+        for (Entry e : children) {
+            self.attachChild(e.entry);
+        }
+    }
+
+    @Override
+    public void detach(GuiControl parent) {
+        this.parent = null;
+        Collection<Entry> copy = new LinkedList<Entry>(children);
+        for (Entry e : copy) {
+            e.entry.removeFromParent();
+        }
+    }
+
+    @Override
+    public VBoxLayout clone() {
+        VBoxLayout result = (VBoxLayout) super.clone();
+        result.parent = null;
+        result.children = new LinkedList<Entry>(children);
+        result.margin = margin;
+        result.fillMode = fillMode;
+        result.fillWidth = fillWidth;
+        result.defaultAlign = defaultAlign;
+
+        return result;
+    }
+
+    private class Entry {
+
+        public final Node entry;
+        public final HAlign align;
+        public final boolean fillWidth;
+        public Vector3f size = new Vector3f();
+
+        private Entry(Node entry, HAlign align, boolean fillWidth) {
+            this.entry = entry;
+            this.align = align;
+            this.fillWidth = fillWidth;
+        }
+    }
+}