Fix for #2279 - Added helper to OrderedLayout and GridLayout for setting component alignments

svn changeset:6163/svn branch:trunk

4 files changed, 356 insertions, 0 deletions

diff --git a/src/com/itmill/toolkit/tests/tickets/Ticket2279.java b/src/com/itmill/toolkit/tests/tickets/Ticket2279.java
new file mode 100644
index 0000000000..b6c71a6f72
--- /dev/null
+++ b/src/com/itmill/toolkit/tests/tickets/Ticket2279.java
@@ -0,0 +1,206 @@
+package com.itmill.toolkit.tests.tickets;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import com.itmill.toolkit.Application;
+import com.itmill.toolkit.terminal.gwt.client.ui.AlignmentInfo;
+import com.itmill.toolkit.ui.AbstractOrderedLayout;
+import com.itmill.toolkit.ui.GridLayout;
+import com.itmill.toolkit.ui.Label;
+import com.itmill.toolkit.ui.Layout;
+import com.itmill.toolkit.ui.VerticalLayout;
+import com.itmill.toolkit.ui.Window;
+import com.itmill.toolkit.ui.Layout.AlignmentHandler;
+
+public class Ticket2279 extends Application {
+
+    private Label label;
+
+    private static Map<String, Integer> expected = new HashMap<String, Integer>();
+
+    private static Set<String> longHorizontalAlignments = new HashSet<String>();
+    private static Set<String> shortHorizontalAlignments = new HashSet<String>();
+    private static Set<String> longVerticalAlignments = new HashSet<String>();
+    private static Set<String> shortVerticalAlignments = new HashSet<String>();
+
+    static {
+        expected.put("r", AlignmentInfo.ALIGNMENT_RIGHT);
+        expected.put("l", AlignmentInfo.ALIGNMENT_LEFT);
+        expected.put("c", AlignmentInfo.ALIGNMENT_HORIZONTAL_CENTER);
+        expected.put("t", AlignmentInfo.ALIGNMENT_TOP);
+        expected.put("b", AlignmentInfo.ALIGNMENT_BOTTOM);
+        expected.put("m", AlignmentInfo.ALIGNMENT_VERTICAL_CENTER);
+
+        expected.put("right", AlignmentInfo.ALIGNMENT_RIGHT);
+        expected.put("left", AlignmentInfo.ALIGNMENT_LEFT);
+        expected.put("center", AlignmentInfo.ALIGNMENT_HORIZONTAL_CENTER);
+        expected.put("top", AlignmentInfo.ALIGNMENT_TOP);
+        expected.put("bottom", AlignmentInfo.ALIGNMENT_BOTTOM);
+        expected.put("middle", AlignmentInfo.ALIGNMENT_VERTICAL_CENTER);
+
+        shortHorizontalAlignments.add("r");
+        shortHorizontalAlignments.add("l");
+        shortHorizontalAlignments.add("c");
+        shortVerticalAlignments.add("t");
+        shortVerticalAlignments.add("b");
+        shortVerticalAlignments.add("m");
+
+        longHorizontalAlignments.add("right");
+        longHorizontalAlignments.add("left");
+        longHorizontalAlignments.add("center");
+        longVerticalAlignments.add("top");
+        longVerticalAlignments.add("bottom");
+        longVerticalAlignments.add("middle");
+
+    }
+
+    public void init() {
+        Window w = new Window(getClass().getSimpleName());
+        setMainWindow(w);
+        setTheme("tests-tickets");
+        AbstractOrderedLayout layout = (AbstractOrderedLayout) w.getLayout();
+
+        createUI(layout);
+    }
+
+    private void createUI(Layout layout) {
+        VerticalLayout vl = new VerticalLayout();
+        vl.setWidth("500px");
+        vl.setHeight("500px");
+        vl.setStyleName("borders");
+        label = new Label("<b>Error messages follows:</b><br/>",
+                Label.CONTENT_XHTML);
+        vl.addComponent(label);
+        layout.addComponent(vl);
+
+        testAlignments(vl);
+
+        GridLayout gl = new GridLayout(1, 1);
+        gl.setWidth("500px");
+        gl.setHeight("500px");
+        gl.setStyleName("borders");
+        label = new Label("<b>Error messages follows:</b><br/>",
+                Label.CONTENT_XHTML);
+        gl.addComponent(label);
+        layout.addComponent(gl);
+
+        testAlignments(gl);
+
+    }
+
+    private void testAlignments(AlignmentHandler layout) {
+        HashSet<String> horizontals = new HashSet<String>();
+        horizontals.addAll(shortHorizontalAlignments);
+        horizontals.addAll(longHorizontalAlignments);
+
+        for (String horiz : horizontals) {
+            // Test "l","r","left","right" etc
+            int expectedHoriz = expected.get(horiz);
+            checkAlignment(layout, horiz, AlignmentHandler.ALIGNMENT_TOP
+                    | expectedHoriz);
+
+            for (String vert : shortVerticalAlignments) {
+                int expectedVert = expected.get(vert);
+
+                // Test "lt","rt" etc
+                if (horiz.length() == 1) {
+                    checkAlignment(layout, horiz + vert, expectedHoriz
+                            | expectedVert);
+                    checkAlignment(layout, vert + horiz, expectedHoriz
+                            | expectedVert);
+                } else {
+                    boolean ok = false;
+                    try {
+                        checkAlignment(layout, horiz + vert, expectedHoriz
+                                | expectedVert);
+                    } catch (IllegalArgumentException e) {
+                        // OK, "centert","rightb" etc are not valid
+                        ok = true;
+                    }
+                    if (!ok) {
+                        error("IllegalArgumentException was not thrown for "
+                                + horiz + vert);
+                    }
+                    ok = false;
+                    try {
+                        checkAlignment(layout, vert + horiz, expectedHoriz
+                                | expectedVert);
+                    } catch (IllegalArgumentException e) {
+                        // OK, "centert","rightb" etc are not valid
+                        ok = true;
+                    }
+                    if (!ok) {
+                        error("IllegalArgumentException was not thrown for "
+                                + horiz + vert);
+                    }
+
+                }
+
+                // Test "l t","r t" etc
+                checkAlignment(layout, horiz + " " + vert, expectedHoriz
+                        | expectedVert);
+                checkAlignment(layout, vert + " " + horiz, expectedHoriz
+                        | expectedVert);
+            }
+
+            for (String vert : longVerticalAlignments) {
+                int expectedVert = expected.get(vert);
+
+                // Test "right t","right b" etc
+                checkAlignment(layout, horiz + " " + vert, expectedHoriz
+                        | expectedVert);
+                checkAlignment(layout, vert + " " + horiz, expectedHoriz
+                        | expectedVert);
+
+                // Three alignments should throw an exception
+                boolean ok = false;
+                try {
+                    checkAlignment(layout, horiz + " " + vert + " " + horiz,
+                            expectedHoriz | expectedVert);
+                } catch (IllegalArgumentException e) {
+                    // OK, "centert","rightb" etc are not valid
+                    ok = true;
+                }
+                if (!ok) {
+                    error("IllegalArgumentException was not thrown for "
+                            + horiz + " " + vert + " " + horiz);
+                }
+            }
+        }
+
+        checkAlignment(layout, "left right", AlignmentHandler.ALIGNMENT_TOP
+                | AlignmentHandler.ALIGNMENT_RIGHT);
+    }
+
+    private void checkAlignment(AlignmentHandler layout,
+            String alignmentString, int expected) {
+        layout.setComponentAlignment(label, AlignmentInfo.ALIGNMENT_TOP,
+                AlignmentInfo.ALIGNMENT_LEFT);
+        if (layout instanceof AbstractOrderedLayout) {
+            ((AbstractOrderedLayout) layout).setComponentAlignment(label,
+                    alignmentString);
+        } else {
+            ((GridLayout) layout).setComponentAlignment(label, alignmentString);
+        }
+
+        int actual = layout.getComponentAlignment(label);
+        if (actual != expected) {
+            String error = "Error " + alignmentString
+                    + " did not produce expected results";
+            error(error);
+        } else {
+            String str = layout.getClass().getSimpleName() + "/"
+                    + alignmentString + ": OK";
+            System.out.println(str);
+        }
+
+    }
+
+    private void error(String error) {
+        label.setValue(label.getValue() + error + "<br/>");
+        System.out.println(error);
+    }
+}
diff --git a/src/com/itmill/toolkit/ui/AbstractOrderedLayout.java b/src/com/itmill/toolkit/ui/AbstractOrderedLayout.java
index fe9d897d71..72d0d42249 100644
--- a/src/com/itmill/toolkit/ui/AbstractOrderedLayout.java
+++ b/src/com/itmill/toolkit/ui/AbstractOrderedLayout.java
@@ -331,4 +331,8 @@ public abstract class AbstractOrderedLayout extends AbstractLayout implements
         return (ratio == null) ? 0 : ratio.floatValue();
     }
 
+    public void setComponentAlignment(Component component, String alignment) {
+        AlignmentUtils.setComponentAlignment(this, component, alignment);
+    }
+
 }
diff --git a/src/com/itmill/toolkit/ui/AlignmentUtils.java b/src/com/itmill/toolkit/ui/AlignmentUtils.java
new file mode 100644
index 0000000000..76ba3d5dc9
--- /dev/null
+++ b/src/com/itmill/toolkit/ui/AlignmentUtils.java
@@ -0,0 +1,142 @@
+package com.itmill.toolkit.ui;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.itmill.toolkit.ui.Layout.AlignmentHandler;
+
+/**
+ * Helper class for setting alignments using a short notation.
+ * 
+ * Supported notation is:
+ * 
+ * t,top for top alignment
+ * 
+ * m,middle for vertical center alignment
+ * 
+ * b,bottom for bottom alignment
+ * 
+ * l,left for left alignment
+ * 
+ * c,center for horizontal center alignment
+ * 
+ * r,right for right alignment
+ * 
+ */
+public class AlignmentUtils {
+
+    private static int horizontalMask = AlignmentHandler.ALIGNMENT_LEFT
+            | AlignmentHandler.ALIGNMENT_HORIZONTAL_CENTER
+            | AlignmentHandler.ALIGNMENT_RIGHT;
+    private static int verticalMask = AlignmentHandler.ALIGNMENT_TOP
+            | AlignmentHandler.ALIGNMENT_VERTICAL_CENTER
+            | AlignmentHandler.ALIGNMENT_BOTTOM;
+
+    private static Map<String, Integer> alignmentStrings = new HashMap();
+
+    private static void addMapping(int alignment, String... values) {
+        for (String s : values) {
+            alignmentStrings.put(s, alignment);
+        }
+    }
+
+    static {
+        addMapping(AlignmentHandler.ALIGNMENT_TOP, "t", "top");
+        addMapping(AlignmentHandler.ALIGNMENT_BOTTOM, "b", "bottom");
+        addMapping(AlignmentHandler.ALIGNMENT_VERTICAL_CENTER, "m", "middle");
+
+        addMapping(AlignmentHandler.ALIGNMENT_LEFT, "l", "left");
+        addMapping(AlignmentHandler.ALIGNMENT_RIGHT, "r", "right");
+        addMapping(AlignmentHandler.ALIGNMENT_HORIZONTAL_CENTER, "c", "center");
+    }
+
+    /**
+     * Set the alignment for the component using short notation
+     * 
+     * @param parent
+     * @param component
+     * @param alignment
+     *            String containing one or two alignment strings. If short
+     *            notation "r","t",etc is used valid strings include
+     *            "r","rt","tr","t". If the longer notation is used the
+     *            alignments should be separated by a space e.g.
+     *            "right","right top","top right","top". It is valid to mix
+     *            short and long notation but they must be separated by a space
+     *            e.g. "r top".
+     * @throws IllegalArgumentException
+     */
+    public static void setComponentAlignment(AlignmentHandler parent,
+            Component component, String alignment)
+            throws IllegalArgumentException {
+        if (alignment == null || alignment.length() == 0) {
+            throw new IllegalArgumentException(
+                    "alignment for setComponentAlignment() cannot be null or empty");
+        }
+
+        Integer currentAlignment = parent.getComponentAlignment(component);
+
+        if (alignment.length() == 1) {
+            // Use short form "t","l",...
+            currentAlignment = parseAlignment(alignment.substring(0, 1),
+                    currentAlignment);
+        } else if (alignment.length() == 2) {
+            // Use short form "tr","lb",...
+            currentAlignment = parseAlignment(alignment.substring(0, 1),
+                    currentAlignment);
+            currentAlignment = parseAlignment(alignment.substring(1, 2),
+                    currentAlignment);
+        } else {
+            // Alignments are separated by space
+            String[] strings = alignment.split(" ");
+            if (strings.length > 2) {
+                throw new IllegalArgumentException(
+                        "alignment for setComponentAlignment() should not contain more than 2 alignments");
+            }
+            for (String alignmentString : strings) {
+                currentAlignment = parseAlignment(alignmentString,
+                        currentAlignment);
+            }
+        }
+
+        int horizontalAlignment = currentAlignment & horizontalMask;
+        int verticalAlignment = currentAlignment & verticalMask;
+        parent.setComponentAlignment(component, horizontalAlignment,
+                verticalAlignment);
+    }
+
+    /**
+     * Parse alignmentString which contains one alignment (horizontal or
+     * vertical) and return and updated version of the passed alignment where
+     * the alignment in one direction has been changed. If the passed
+     * alignmentString is unknown an exception is thrown
+     * 
+     * @param alignmentString
+     * @param alignment
+     * @return
+     * @throws IllegalArgumentException
+     */
+    private static int parseAlignment(String alignmentString, int alignment)
+            throws IllegalArgumentException {
+        Integer parsed = alignmentStrings.get(alignmentString.toLowerCase());
+
+        if (parsed == null) {
+            throw new IllegalArgumentException(
+                    "Could not parse alignment string '" + alignmentString
+                            + "'");
+        }
+
+        if ((parsed & horizontalMask) != 0) {
+            // Get the vertical alignment from the current alignment
+            int vertical = (alignment & verticalMask);
+            // Add the parsed horizontal alignment
+            alignment = (vertical | parsed);
+        } else {
+            // Get the horizontal alignment from the current alignment
+            int horizontal = (alignment & horizontalMask);
+            // Add the parsed vertical alignment
+            alignment = (horizontal | parsed);
+        }
+
+        return alignment;
+    }
+}
diff --git a/src/com/itmill/toolkit/ui/GridLayout.java b/src/com/itmill/toolkit/ui/GridLayout.java
index c12ea25c96..0b43cb6ba5 100644
--- a/src/com/itmill/toolkit/ui/GridLayout.java
+++ b/src/com/itmill/toolkit/ui/GridLayout.java
@@ -1287,4 +1287,8 @@ public class GridLayout extends AbstractLayout implements
         return null;
     }
 
+    public void setComponentAlignment(Component component, String alignment) {
+        AlignmentUtils.setComponentAlignment(this, component, alignment);
+    }
+
 }