Merge commit '56d0c'

Conflicts:
	src/com/vaadin/terminal/gwt/client/ui/ClickEventHandler.java
	src/com/vaadin/terminal/gwt/client/ui/combobox/VFilterSelect.java
	src/com/vaadin/terminal/gwt/client/ui/splitpanel/VAbstractSplitPanel.java
	src/com/vaadin/ui/AbstractSplitPanel.java

6 files changed, 301 insertions, 29 deletions

diff --git a/src/com/vaadin/terminal/gwt/client/Util.java b/src/com/vaadin/terminal/gwt/client/Util.java
index 010d30e49c..d3cb54160d 100644
--- a/src/com/vaadin/terminal/gwt/client/Util.java
+++ b/src/com/vaadin/terminal/gwt/client/Util.java
@@ -913,7 +913,7 @@ public class Util {
     /**
      * Find the element corresponding to the coordinates in the passed mouse
      * event. Please note that this is not always the same as the target of the
-     * element e.g. if event capture is used.
+     * event e.g. if event capture is used.
      * 
      * @param event
      *            the mouse event to get coordinates from
diff --git a/src/com/vaadin/terminal/gwt/client/ui/combobox/VFilterSelect.java b/src/com/vaadin/terminal/gwt/client/ui/combobox/VFilterSelect.java
index 70ec5e088a..00da2f3adf 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/combobox/VFilterSelect.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/combobox/VFilterSelect.java
@@ -69,7 +69,8 @@ import com.vaadin.terminal.gwt.client.ui.menubar.MenuItem;
  */
 @SuppressWarnings("deprecation")
 public class VFilterSelect extends Composite implements Field, KeyDownHandler,
-        KeyUpHandler, ClickHandler, FocusHandler, BlurHandler, Focusable {
+        KeyUpHandler, ClickHandler, FocusHandler, BlurHandler, Focusable,
+        SubPartAware {
 
     /**
      * Represents a suggestion in the suggestion popup box
@@ -1689,4 +1690,24 @@ public class VFilterSelect extends Composite implements Field, KeyDownHandler,
         super.onDetach();
         suggestionPopup.hide();
     }
+
+    @Override
+    public Element getSubPartElement(String subPart) {
+        if ("textbox".equals(subPart)) {
+            return this.tb.getElement();
+        } else if ("button".equals(subPart)) {
+            return this.popupOpener.getElement();
+        }
+        return null;
+    }
+
+    @Override
+    public String getSubPartName(Element subElement) {
+        if (tb.getElement().isOrHasChild(subElement)) {
+            return "textbox";
+        } else if (popupOpener.getElement().isOrHasChild(subElement)) {
+            return "button";
+        }
+        return null;
+    }
 }
diff --git a/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelConnector.java b/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelConnector.java
index 10e5dbe37a..b5cedc42d4 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelConnector.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelConnector.java
@@ -41,6 +41,7 @@ public abstract class AbstractSplitPanelConnector extends
 
         getWidget().addHandler(new SplitterMoveHandler() {
 
+            @Override
             public void splitterMoved(SplitterMoveEvent event) {
                 String position = getWidget().getSplitterPosition();
                 float pos = 0;
@@ -61,6 +62,7 @@ public abstract class AbstractSplitPanelConnector extends
         }, SplitterMoveEvent.TYPE);
     }
 
+    @Override
     public void updateCaption(ComponentConnector component) {
         // TODO Implement caption handling
     }
@@ -127,6 +129,12 @@ public abstract class AbstractSplitPanelConnector extends
 
         getWidget().setStylenames();
 
+        getWidget().minimumPosition = splitterState.getMinPosition()
+                + splitterState.getMinPositionUnit();
+
+        getWidget().maximumPosition = splitterState.getMaxPosition()
+                + splitterState.getMaxPositionUnit();
+
         getWidget().position = splitterState.getPosition()
                 + splitterState.getPositionUnit();
 
@@ -138,6 +146,7 @@ public abstract class AbstractSplitPanelConnector extends
 
     }
 
+    @Override
     public void layout() {
         VAbstractSplitPanel splitPanel = getWidget();
         splitPanel.setSplitPosition(splitPanel.position);
diff --git a/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelState.java b/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelState.java
index 8b80eed840..db3a39d3a5 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelState.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/splitpanel/AbstractSplitPanelState.java
@@ -49,6 +49,10 @@ public class AbstractSplitPanelState extends ComponentState {
     public static class SplitterState implements Serializable {
         private float position;
         private String positionUnit;
+        private float minPosition;
+        private String minPositionUnit;
+        private float maxPosition;
+        private String maxPositionUnit;
         private boolean positionReversed = false;
         private boolean locked = false;
 
@@ -68,6 +72,38 @@ public class AbstractSplitPanelState extends ComponentState {
             this.positionUnit = positionUnit;
         }
 
+        public float getMinPosition() {
+            return minPosition;
+        }
+
+        public void setMinPosition(float minPosition) {
+            this.minPosition = minPosition;
+        }
+
+        public String getMinPositionUnit() {
+            return minPositionUnit;
+        }
+
+        public void setMinPositionUnit(String minPositionUnit) {
+            this.minPositionUnit = minPositionUnit;
+        }
+
+        public float getMaxPosition() {
+            return maxPosition;
+        }
+
+        public void setMaxPosition(float maxPosition) {
+            this.maxPosition = maxPosition;
+        }
+
+        public String getMaxPositionUnit() {
+            return maxPositionUnit;
+        }
+
+        public void setMaxPositionUnit(String maxPositionUnit) {
+            this.maxPositionUnit = maxPositionUnit;
+        }
+
         public boolean isPositionReversed() {
             return positionReversed;
         }
diff --git a/src/com/vaadin/terminal/gwt/client/ui/splitpanel/VAbstractSplitPanel.java b/src/com/vaadin/terminal/gwt/client/ui/splitpanel/VAbstractSplitPanel.java
index 4204c81f38..72e63cedca 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/splitpanel/VAbstractSplitPanel.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/splitpanel/VAbstractSplitPanel.java
@@ -88,6 +88,10 @@ public class VAbstractSplitPanel extends ComplexPanel {
     /* The current position of the split handle in either percentages or pixels */
     String position;
 
+    String maximumPosition;
+
+    String minimumPosition;
+
     private final TouchScrollHandler touchScrollHandler;
 
     protected Element scrolledContainer;
@@ -222,11 +226,113 @@ public class VAbstractSplitPanel extends ComplexPanel {
         }
     }
 
+    /**
+     * Converts given split position string (in pixels or percentage) to a
+     * floating point pixel value.
+     * 
+     * @param pos
+     * @return
+     */
+    private float convertToPixels(String pos) {
+        float posAsFloat;
+        if (pos.indexOf("%") > 0) {
+            posAsFloat = Math.round(Float.parseFloat(pos.substring(0,
+                    pos.length() - 1))
+                    / 100
+                    * (orientation == ORIENTATION_HORIZONTAL ? getOffsetWidth()
+                            : getOffsetHeight()));
+        } else {
+            posAsFloat = Float.parseFloat(pos.substring(0, pos.length() - 2));
+        }
+        return posAsFloat;
+    }
+
+    /**
+     * Converts given split position string (in pixels or percentage) to a float
+     * percentage value.
+     * 
+     * @param pos
+     * @return
+     */
+    private float convertToPercentage(String pos) {
+        float posAsFloat = 0;
+
+        if (pos.indexOf("px") > 0) {
+            int posAsInt = Integer.parseInt(pos.substring(0, pos.length() - 2));
+            int offsetLength = orientation == ORIENTATION_HORIZONTAL ? getOffsetWidth()
+                    : getOffsetHeight();
+
+            // 100% needs special handling
+            if (posAsInt + getSplitterSize() >= offsetLength) {
+                posAsInt = offsetLength;
+            }
+            // Reversed position
+            if (positionReversed) {
+                posAsInt = offsetLength - posAsInt - getSplitterSize();
+            }
+            posAsFloat = ((float) posAsInt / (float) getOffsetWidth() * 100);
+
+        } else {
+            posAsFloat = Float.parseFloat(pos.substring(0, pos.length() - 1));
+        }
+        return posAsFloat;
+    }
+
+    /**
+     * Returns the given position clamped to the range between current minimum
+     * and maximum positions.
+     * 
+     * TODO Should this be in the connector?
+     * 
+     * @param pos
+     *            Position of the splitter as a CSS string, either pixels or a
+     *            percentage.
+     * @return minimumPosition if pos is less than minimumPosition;
+     *         maximumPosition if pos is greater than maximumPosition; pos
+     *         otherwise.
+     */
+    private String checkSplitPositionLimits(String pos) {
+        float positionAsFloat = convertToPixels(pos);
+        float maximumAsFloat = convertToPixels(maximumPosition);
+        float minimumAsFloat = convertToPixels(minimumPosition);
+
+        if (maximumAsFloat < positionAsFloat) {
+            pos = maximumPosition;
+        } else if (minimumAsFloat > positionAsFloat) {
+            pos = minimumPosition;
+        }
+        return pos;
+    }
+
+    /**
+     * Converts given string to the same units as the split position is.
+     * 
+     * @param pos
+     *            position to be converted
+     * @return converted position string
+     */
+    private String convertToPositionUnits(String pos) {
+        if (position.indexOf("%") != -1 && pos.indexOf("%") == -1) {
+            // position is in percentage, pos in pixels
+            pos = convertToPercentage(pos) + "%";
+        } else if (position.indexOf("px") > 0 && pos.indexOf("px") == -1) {
+            // position is in pixels and pos in percentage
+            pos = convertToPixels(pos) + "px";
+        }
+
+        return pos;
+    }
+
     void setSplitPosition(String pos) {
         if (pos == null) {
             return;
         }
 
+        pos = checkSplitPositionLimits(pos);
+        if (!pos.equals(position)) {
+            position = convertToPositionUnits(pos);
+        }
+
         // Convert percentage values to pixels
         if (pos.indexOf("%") > 0) {
             int size = orientation == ORIENTATION_HORIZONTAL ? getOffsetWidth()
@@ -470,16 +576,7 @@ public class VAbstractSplitPanel extends ComplexPanel {
         }
 
         if (position.indexOf("%") > 0) {
-            float pos = newX;
-            // 100% needs special handling
-            if (newX + getSplitterSize() >= getOffsetWidth()) {
-                pos = getOffsetWidth();
-            }
-            // Reversed position
-            if (positionReversed) {
-                pos = getOffsetWidth() - pos - getSplitterSize();
-            }
-            position = (pos / getOffsetWidth() * 100) + "%";
+            position = convertToPositionUnits(newX + "px");
         } else {
             // Reversed position
             if (positionReversed) {
@@ -512,16 +609,7 @@ public class VAbstractSplitPanel extends ComplexPanel {
         }
 
         if (position.indexOf("%") > 0) {
-            float pos = newY;
-            // 100% needs special handling
-            if (newY + getSplitterSize() >= getOffsetHeight()) {
-                pos = getOffsetHeight();
-            }
-            // Reversed position
-            if (positionReversed) {
-                pos = getOffsetHeight() - pos - getSplitterSize();
-            }
-            position = pos / getOffsetHeight() * 100 + "%";
+            position = convertToPositionUnits(newY + "px");
         } else {
             // Reversed position
             if (positionReversed) {
@@ -647,7 +735,7 @@ public class VAbstractSplitPanel extends ComplexPanel {
         return splitterSize;
     }
 
-    private void setStylenames() {
+    void setStylenames() {
         final String splitterClass = CLASSNAME
                 + (orientation == ORIENTATION_HORIZONTAL ? "-hsplitter"
                         : "-vsplitter");
diff --git a/src/com/vaadin/ui/AbstractSplitPanel.java b/src/com/vaadin/ui/AbstractSplitPanel.java
index 5205952621..805640387f 100644
--- a/src/com/vaadin/ui/AbstractSplitPanel.java
+++ b/src/com/vaadin/ui/AbstractSplitPanel.java
@@ -22,7 +22,7 @@ import com.vaadin.tools.ReflectTools;
  * AbstractSplitPanel.
  * 
  * <code>AbstractSplitPanel</code> is base class for a component container that
- * can contain two components. The comopnents are split by a divider element.
+ * can contain two components. The components are split by a divider element.
  * 
  * @author Vaadin Ltd.
  * @version
@@ -31,17 +31,22 @@ import com.vaadin.tools.ReflectTools;
  */
 public abstract class AbstractSplitPanel extends AbstractComponentContainer {
 
+    // TODO use Unit in AbstractSplitPanelState and remove these
     private Unit posUnit;
+    private Unit posMinUnit = Unit.PERCENTAGE;
+    private Unit posMaxUnit = Unit.PERCENTAGE;
 
     private AbstractSplitPanelRpc rpc = new AbstractSplitPanelRpc() {
 
+        @Override
         public void splitterClick(MouseEventDetails mouseDetails) {
             fireEvent(new SplitterClickEvent(AbstractSplitPanel.this,
                     mouseDetails));
         }
 
+        @Override
         public void setSplitterPosition(float position) {
-            getState().getSplitterState().setPosition(position);
+            getSplitterState().setPosition(position);
         }
     };
 
@@ -59,6 +64,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
 
         int i = 0;
 
+        @Override
         public boolean hasNext() {
             if (i < getComponentCount()) {
                 return true;
@@ -66,6 +72,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
             return false;
         }
 
+        @Override
         public Component next() {
             if (!hasNext()) {
                 return null;
@@ -80,6 +87,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
             return null;
         }
 
+        @Override
         public void remove() {
             if (i == 1) {
                 if (getFirstComponent() != null) {
@@ -204,6 +212,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
      * 
      * @see com.vaadin.ui.ComponentContainer#getComponentIterator()
      */
+    @Override
     public Iterator<Component> getComponentIterator() {
         return new ComponentIterator();
     }
@@ -214,6 +223,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
      * 
      * @return the number of contained components (zero, one or two)
      */
+    @Override
     public int getComponentCount() {
         int count = 0;
         if (getFirstComponent() != null) {
@@ -226,6 +236,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
     }
 
     /* Documented in superclass */
+    @Override
     public void replaceComponent(Component oldComponent, Component newComponent) {
         if (oldComponent == getFirstComponent()) {
             setFirstComponent(newComponent);
@@ -297,7 +308,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
         if (unit != Unit.PERCENTAGE) {
             pos = Math.round(pos);
         }
-        SplitterState splitterState = getState().getSplitterState();
+        SplitterState splitterState = getSplitterState();
         splitterState.setPosition(pos);
         splitterState.setPositionUnit(unit.getSymbol());
         splitterState.setPositionReversed(reverse);
@@ -313,7 +324,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
      * @return position of the splitter
      */
     public float getSplitPosition() {
-        return getState().getSplitterState().getPosition();
+        return getSplitterState().getPosition();
     }
 
     /**
@@ -326,6 +337,110 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
     }
 
     /**
+     * Sets the minimum split position to the given position and unit. If the
+     * split position is reversed, maximum and minimum are also reversed.
+     * 
+     * @param pos
+     *            the minimum position of the split
+     * @param unit
+     *            the unit (from {@link Sizeable}) in which the size is given.
+     *            Allowed units are UNITS_PERCENTAGE and UNITS_PIXELS
+     */
+    public void setMinimumSplitPosition(int pos, Unit unit) {
+        setSplitPositionLimits(pos, unit, getSplitterState().getMaxPosition(),
+                posMaxUnit);
+    }
+
+    /**
+     * Returns the current minimum position of the splitter, in
+     * {@link #getMinSplitPositionUnit()} units.
+     * 
+     * @return the minimum position of the splitter
+     */
+    public float getMinSplitPosition() {
+        return getSplitterState().getMinPosition();
+    }
+
+    /**
+     * Returns the unit of the minimum position of the splitter.
+     * 
+     * @return the unit of the minimum position of the splitter
+     */
+    public Unit getMinSplitPositionUnit() {
+        return posMinUnit;
+    }
+
+    /**
+     * Sets the maximum split position to the given position and unit. If the
+     * split position is reversed, maximum and minimum are also reversed.
+     * 
+     * @param pos
+     *            the maximum position of the split
+     * @param unit
+     *            the unit (from {@link Sizeable}) in which the size is given.
+     *            Allowed units are UNITS_PERCENTAGE and UNITS_PIXELS
+     */
+    public void setMaxSplitPosition(int pos, Unit unit) {
+        setSplitPositionLimits(getSplitterState().getMinPosition(), posMinUnit,
+                pos, unit);
+    }
+
+    /**
+     * Returns the current maximum position of the splitter, in
+     * {@link #getMaxSplitPositionUnit()} units.
+     * 
+     * @return the maximum position of the splitter
+     */
+    public float getMaxSplitPosition() {
+        return getSplitterState().getMaxPosition();
+    }
+
+    /**
+     * Returns the unit of the maximum position of the splitter
+     * 
+     * @return the unit of the maximum position of the splitter
+     */
+    public Unit getMaxSplitPositionUnit() {
+        return posMaxUnit;
+    }
+
+    /**
+     * Sets the maximum and minimum position of the splitter. If the split
+     * position is reversed, maximum and minimum are also reversed.
+     * 
+     * @param minPos
+     *            the new minimum position
+     * @param minPosUnit
+     *            the unit (from {@link Sizeable}) in which the minimum position
+     *            is given.
+     * @param maxPos
+     *            the new maximum position
+     * @param maxPosUnit
+     *            the unit (from {@link Sizeable}) in which the maximum position
+     *            is given.
+     */
+    private void setSplitPositionLimits(float minPos, Unit minPosUnit,
+            float maxPos, Unit maxPosUnit) {
+        if ((minPosUnit != Unit.PERCENTAGE && minPosUnit != Unit.PIXELS)
+                || (maxPosUnit != Unit.PERCENTAGE && maxPosUnit != Unit.PIXELS)) {
+            throw new IllegalArgumentException(
+                    "Only percentage and pixel units are allowed");
+        }
+
+        SplitterState state = getSplitterState();
+
+        state.setMinPosition(minPos);
+        state.setMinPositionUnit("" + minPosUnit);
+        posMinUnit = minPosUnit;
+
+        state.setMaxPosition(maxPos);
+        state.setMaxPositionUnit("" + maxPosUnit);
+        posMaxUnit = maxPosUnit;
+
+        requestRepaint();
+    }
+
+    /**
      * Lock the SplitPanels position, disabling the user from dragging the split
      * handle.
      * 
@@ -333,7 +448,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
      *            Set <code>true</code> if locked, <code>false</code> otherwise.
      */
     public void setLocked(boolean locked) {
-        getState().getSplitterState().setLocked(locked);
+        getSplitterState().setLocked(locked);
         requestRepaint();
     }
 
@@ -344,7 +459,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
      * @return <code>true</code> if locked, <code>false</code> otherwise.
      */
     public boolean isLocked() {
-        return getState().getSplitterState().isLocked();
+        return getSplitterState().isLocked();
     }
 
     /**
@@ -394,4 +509,7 @@ public abstract class AbstractSplitPanel extends AbstractComponentContainer {
         return (AbstractSplitPanelState) super.getState();
     }
 
+    private SplitterState getSplitterState() {
+        return getState().getSplitterState();
+    }
 }