package com.itmill.toolkit.terminal.gwt.client.ui;
-public class AlignmentInfo {
-
- public static final int ALIGNMENT_LEFT = 1;
- public static final int ALIGNMENT_RIGHT = 2;
- public static final int ALIGNMENT_TOP = 4;
- public static final int ALIGNMENT_BOTTOM = 8;
- public static final int ALIGNMENT_HORIZONTAL_CENTER = 16;
- public static final int ALIGNMENT_VERTICAL_CENTER = 32;
+public final class AlignmentInfo {
+ /** Bitmask values for client server communication */
+ public static class Bits {
+ public static final int ALIGNMENT_LEFT = 1;
+ public static final int ALIGNMENT_RIGHT = 2;
+ public static final int ALIGNMENT_TOP = 4;
+ public static final int ALIGNMENT_BOTTOM = 8;
+ public static final int ALIGNMENT_HORIZONTAL_CENTER = 16;
+ public static final int ALIGNMENT_VERTICAL_CENTER = 32;
+ }
- private int bitMask;
+ public static final AlignmentInfo LEFT = new AlignmentInfo(
+ Bits.ALIGNMENT_LEFT);
+ public static final AlignmentInfo RIGHT = new AlignmentInfo(
+ Bits.ALIGNMENT_RIGHT);
+ public static final AlignmentInfo TOP = new AlignmentInfo(
+ Bits.ALIGNMENT_TOP);
+ public static final AlignmentInfo BOTTOM = new AlignmentInfo(
+ Bits.ALIGNMENT_BOTTOM);
+ public static final AlignmentInfo CENTER = new AlignmentInfo(
+ Bits.ALIGNMENT_HORIZONTAL_CENTER);
+ public static final AlignmentInfo MIDDLE = new AlignmentInfo(
+ Bits.ALIGNMENT_VERTICAL_CENTER);
+ public static final AlignmentInfo TOP_LEFT = new AlignmentInfo(
+ Bits.ALIGNMENT_TOP + Bits.ALIGNMENT_LEFT);
+
+ private final int bitMask;
public AlignmentInfo(int bitMask) {
this.bitMask = bitMask;
}
- public AlignmentInfo(int horizontal, int vertical) {
- setAlignment(horizontal, vertical);
- }
-
- public void setAlignment(int horiz, int vert) {
- bitMask = horiz + vert;
+ public AlignmentInfo(AlignmentInfo horizontal, AlignmentInfo vertical) {
+ this(horizontal.getBitMask() + vertical.getBitMask());
}
public int getBitMask() {
}
public boolean isTop() {
- return (bitMask & ALIGNMENT_TOP) == ALIGNMENT_TOP;
+ return (bitMask & Bits.ALIGNMENT_TOP) == Bits.ALIGNMENT_TOP;
}
public boolean isBottom() {
- return (bitMask & ALIGNMENT_BOTTOM) == ALIGNMENT_BOTTOM;
+ return (bitMask & Bits.ALIGNMENT_BOTTOM) == Bits.ALIGNMENT_BOTTOM;
}
public boolean isLeft() {
- return (bitMask & ALIGNMENT_LEFT) == ALIGNMENT_LEFT;
+ return (bitMask & Bits.ALIGNMENT_LEFT) == Bits.ALIGNMENT_LEFT;
}
public boolean isRight() {
- return (bitMask & ALIGNMENT_RIGHT) == ALIGNMENT_RIGHT;
+ return (bitMask & Bits.ALIGNMENT_RIGHT) == Bits.ALIGNMENT_RIGHT;
}
public boolean isVerticalCenter() {
- return (bitMask & ALIGNMENT_VERTICAL_CENTER) == ALIGNMENT_VERTICAL_CENTER;
+ return (bitMask & Bits.ALIGNMENT_VERTICAL_CENTER) == Bits.ALIGNMENT_VERTICAL_CENTER;
}
public boolean isHorizontalCenter() {
- return (bitMask & ALIGNMENT_HORIZONTAL_CENTER) == ALIGNMENT_HORIZONTAL_CENTER;
+ return (bitMask & Bits.ALIGNMENT_HORIZONTAL_CENTER) == Bits.ALIGNMENT_HORIZONTAL_CENTER;
}
public String getVerticalAlignment() {
private int containerMarginLeft = 0;
private int containerMarginTop = 0;
- AlignmentInfo alignment = new AlignmentInfo(AlignmentInfo.ALIGNMENT_LEFT,
- AlignmentInfo.ALIGNMENT_TOP);
+ AlignmentInfo alignment = AlignmentInfo.TOP_LEFT;
+
private int alignmentLeftOffsetForWidget = 0;
private int alignmentLeftOffsetForCaption = 0;
/**
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);
+ expected.put("r", AlignmentInfo.Bits.ALIGNMENT_RIGHT);
+ expected.put("l", AlignmentInfo.Bits.ALIGNMENT_LEFT);
+ expected.put("c", AlignmentInfo.Bits.ALIGNMENT_HORIZONTAL_CENTER);
+ expected.put("t", AlignmentInfo.Bits.ALIGNMENT_TOP);
+ expected.put("b", AlignmentInfo.Bits.ALIGNMENT_BOTTOM);
+ expected.put("m", AlignmentInfo.Bits.ALIGNMENT_VERTICAL_CENTER);
+
+ expected.put("right", AlignmentInfo.Bits.ALIGNMENT_RIGHT);
+ expected.put("left", AlignmentInfo.Bits.ALIGNMENT_LEFT);
+ expected.put("center", AlignmentInfo.Bits.ALIGNMENT_HORIZONTAL_CENTER);
+ expected.put("top", AlignmentInfo.Bits.ALIGNMENT_TOP);
+ expected.put("bottom", AlignmentInfo.Bits.ALIGNMENT_BOTTOM);
+ expected.put("middle", AlignmentInfo.Bits.ALIGNMENT_VERTICAL_CENTER);
shortHorizontalAlignments.add("r");
shortHorizontalAlignments.add("l");
private void checkAlignment(AlignmentHandler layout,
String alignmentString, int expected) {
- layout.setComponentAlignment(label, AlignmentInfo.ALIGNMENT_TOP,
- AlignmentInfo.ALIGNMENT_LEFT);
+ layout.setComponentAlignment(label, AlignmentInfo.Bits.ALIGNMENT_TOP,
+ AlignmentInfo.Bits.ALIGNMENT_LEFT);
if (layout instanceof AbstractOrderedLayout) {
((AbstractOrderedLayout) layout).setComponentAlignment(label,
alignmentString);
((GridLayout) layout).setComponentAlignment(label, alignmentString);
}
- int actual = layout.getComponentAlignment(label);
+ int actual = layout.getComponentAlignment(label).getBitMask();
if (actual != expected) {
String error = "Error " + alignmentString
+ " did not produce expected results";
--- /dev/null
+package com.itmill.toolkit.tests.tickets;
+
+import com.itmill.toolkit.Application;
+import com.itmill.toolkit.ui.Alignment;
+import com.itmill.toolkit.ui.GridLayout;
+import com.itmill.toolkit.ui.HorizontalLayout;
+import com.itmill.toolkit.ui.Label;
+import com.itmill.toolkit.ui.Layout;
+import com.itmill.toolkit.ui.Window;
+import com.itmill.toolkit.ui.Layout.AlignmentHandler;
+import com.itmill.toolkit.ui.Layout.SpacingHandler;
+
+public class Ticket2432 extends Application {
+
+ @Override
+ public void init() {
+
+ Window w = new Window();
+ setMainWindow(w);
+ w.getLayout().setSizeFull();
+ ((SpacingHandler) w.getLayout()).setSpacing(true);
+
+ Layout layout = new GridLayout(3, 3);
+ populateLayout(layout);
+ w.addComponent(layout);
+ layout = new HorizontalLayout();
+ populateLayout(layout);
+ w.addComponent(layout);
+
+ }
+
+ private static Alignment[] alignments = new Alignment[] {
+ Alignment.TOP_LEFT, Alignment.TOP_CENTER, Alignment.TOP_RIGHT,
+ Alignment.MIDDLE_LEFT, Alignment.MIDDLE_CENTER,
+ Alignment.MIDDLE_RIGHT, Alignment.BOTTOM_LEFT,
+ Alignment.BOTTOM_CENTER, Alignment.BOTTOM_RIGHT };
+
+ private void populateLayout(Layout layout) {
+ layout.setSizeFull();
+ for (int i = 0; i < 9; i++) {
+ Label l = new Label("M");
+ Alignment a = alignments[i];
+ l.setCaption(a.getHorizontalAlignment() + " "
+ + a.getVerticalAlignment() + " " + a.getBitMask());
+ layout.addComponent(l);
+ ((AlignmentHandler) layout).setComponentAlignment(l, a);
+ }
+
+ }
+
+}
public abstract class AbstractOrderedLayout extends AbstractLayout implements
Layout.AlignmentHandler, Layout.SpacingHandler {
- private static final int ALIGNMENT_DEFAULT = ALIGNMENT_TOP + ALIGNMENT_LEFT;
+ private static final Alignment ALIGNMENT_DEFAULT = Alignment.TOP_LEFT;
/**
* Custom layout slots containing the components.
*/
- protected LinkedList components = new LinkedList();
+ protected LinkedList<Component> components = new LinkedList<Component>();
/* Child component alignments */
/**
* Mapping from components to alignments (horizontal + vertical).
*/
- private final Map componentToAlignment = new HashMap();
+ private final Map<Component, Alignment> componentToAlignment = new HashMap<Component, Alignment>();
private final Map<Component, Float> componentToExpandRatio = new HashMap<Component, Float>();
// Paint child component UIDL
c.paint(target);
alignmentsArray[index] = String
- .valueOf(getComponentAlignment(c));
+ .valueOf(getComponentAlignment(c).getBitMask());
if (!equallyDivided) {
int myRatio = Math.round((getExpandRatio(c) / sum) * 1000);
expandRatioArray[index] = myRatio;
public void setComponentAlignment(Component childComponent,
int horizontalAlignment, int verticalAlignment) {
if (components.contains(childComponent)) {
- componentToAlignment.put(childComponent, new Integer(
+ // Alignments are bit masks
+ componentToAlignment.put(childComponent, new Alignment(
horizontalAlignment + verticalAlignment));
requestRepaint();
} else {
}
}
+ public void setComponentAlignment(Component childComponent,
+ Alignment alignment) {
+ if (components.contains(childComponent)) {
+ componentToAlignment.put(childComponent, alignment);
+ requestRepaint();
+ } else {
+ throw new IllegalArgumentException(
+ "Component must be added to layout before using setComponentAlignment()");
+ }
+
+ }
+
/*
* (non-Javadoc)
*
* com.itmill.toolkit.ui.Layout.AlignmentHandler#getComponentAlignment(com
* .itmill.toolkit.ui.Component)
*/
- public int getComponentAlignment(Component childComponent) {
- final Integer bitMask = (Integer) componentToAlignment
- .get(childComponent);
- if (bitMask != null) {
- return bitMask.intValue();
- } else {
+ public Alignment getComponentAlignment(Component childComponent) {
+ Alignment alignment = componentToAlignment.get(childComponent);
+ if (alignment == null) {
return ALIGNMENT_DEFAULT;
+ } else {
+ return alignment;
}
}
--- /dev/null
+package com.itmill.toolkit.ui;
+
+import com.itmill.toolkit.terminal.gwt.client.ui.AlignmentInfo.Bits;
+
+/**
+ * Class containing information about alignment of a component. Use the
+ * pre-instantiated classes.
+ */
+public final class Alignment {
+
+ public static final Alignment TOP_RIGHT = new Alignment(Bits.ALIGNMENT_TOP
+ + Bits.ALIGNMENT_RIGHT);
+ public static final Alignment TOP_LEFT = new Alignment(Bits.ALIGNMENT_TOP
+ + Bits.ALIGNMENT_LEFT);
+ public static final Alignment TOP_CENTER = new Alignment(Bits.ALIGNMENT_TOP
+ + Bits.ALIGNMENT_HORIZONTAL_CENTER);
+ public static final Alignment MIDDLE_RIGHT = new Alignment(
+ Bits.ALIGNMENT_VERTICAL_CENTER + Bits.ALIGNMENT_RIGHT);
+ public static final Alignment MIDDLE_LEFT = new Alignment(
+ Bits.ALIGNMENT_VERTICAL_CENTER + Bits.ALIGNMENT_LEFT);
+ public static final Alignment MIDDLE_CENTER = new Alignment(
+ Bits.ALIGNMENT_VERTICAL_CENTER + Bits.ALIGNMENT_HORIZONTAL_CENTER);
+ public static final Alignment BOTTOM_RIGHT = new Alignment(
+ Bits.ALIGNMENT_BOTTOM + Bits.ALIGNMENT_RIGHT);
+ public static final Alignment BOTTOM_LEFT = new Alignment(
+ Bits.ALIGNMENT_BOTTOM + Bits.ALIGNMENT_LEFT);
+ public static final Alignment BOTTOM_CENTER = new Alignment(
+ Bits.ALIGNMENT_BOTTOM + Bits.ALIGNMENT_HORIZONTAL_CENTER);
+
+ private final int bitMask;
+
+ public Alignment(int bitMask) {
+ this.bitMask = bitMask;
+ }
+
+ /**
+ * Returns a bitmask representation of the alignment value. Used internally
+ * by terminal.
+ *
+ * @return the bitmask representation of the alignment value
+ */
+ public int getBitMask() {
+ return bitMask;
+ }
+
+ /**
+ * Checks if component is aligned to the top of the available space.
+ *
+ * @return true if aligned top
+ */
+ public boolean isTop() {
+ return (bitMask & Bits.ALIGNMENT_TOP) == Bits.ALIGNMENT_TOP;
+ }
+
+ /**
+ * Checks if component is aligned to the bottom of the available space.
+ *
+ * @return true if aligned bottom
+ */
+ public boolean isBottom() {
+ return (bitMask & Bits.ALIGNMENT_BOTTOM) == Bits.ALIGNMENT_BOTTOM;
+ }
+
+ /**
+ * Checks if component is aligned to the left of the available space.
+ *
+ * @return true if aligned left
+ */
+ public boolean isLeft() {
+ return (bitMask & Bits.ALIGNMENT_LEFT) == Bits.ALIGNMENT_LEFT;
+ }
+
+ /**
+ * Checks if component is aligned to the right of the available space.
+ *
+ * @return true if aligned right
+ */
+ public boolean isRight() {
+ return (bitMask & Bits.ALIGNMENT_RIGHT) == Bits.ALIGNMENT_RIGHT;
+ }
+
+ /**
+ * Checks if component is aligned middle (vertically center) of the
+ * available space.
+ *
+ * @return true if aligned bottom
+ */
+ public boolean isMiddle() {
+ return (bitMask & Bits.ALIGNMENT_VERTICAL_CENTER) == Bits.ALIGNMENT_VERTICAL_CENTER;
+ }
+
+ /**
+ * Checks if component is aligned center (horizontally) of the available
+ * space.
+ *
+ * @return true if aligned center
+ */
+ public boolean isCenter() {
+ return (bitMask & Bits.ALIGNMENT_HORIZONTAL_CENTER) == Bits.ALIGNMENT_HORIZONTAL_CENTER;
+ }
+
+ /**
+ * Returns string representation of vertical alignment.
+ *
+ * @return vertical alignment as CSS value
+ */
+ public String getVerticalAlignment() {
+ if (isBottom()) {
+ return "bottom";
+ } else if (isMiddle()) {
+ return "middle";
+ }
+ return "top";
+ }
+
+ /**
+ * Returns string representation of horizontal alignment.
+ *
+ * @return horizontal alignment as CSS value
+ */
+ public String getHorizontalAlignment() {
+ if (isRight()) {
+ return "right";
+ } else if (isCenter()) {
+ return "center";
+ }
+ return "left";
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if ((obj == null) || (obj.getClass() != this.getClass())) {
+ return false;
+ }
+ Alignment a = (Alignment) obj;
+ return bitMask == a.bitMask;
+ }
+
+ @Override
+ public int hashCode() {
+ return bitMask;
+ }
+
+ @Override
+ public String toString() {
+ return String.valueOf(bitMask);
+ }
+
+}
"alignment for setComponentAlignment() cannot be null or empty");
}
- Integer currentAlignment = parent.getComponentAlignment(component);
+ Integer currentAlignment = parent.getComponentAlignment(component)
+ .getBitMask();
if (alignment.length() == 1) {
// Use short form "t","l",...
int horizontalAlignment = currentAlignment & horizontalMask;
int verticalAlignment = currentAlignment & verticalMask;
- parent.setComponentAlignment(component, horizontalAlignment,
- verticalAlignment);
+ parent.setComponentAlignment(component, new Alignment(
+ horizontalAlignment + verticalAlignment));
}
/**
/**
* Mapping from components to alignments (horizontal + vertical).
*/
- private Map componentToAlignment = new HashMap();
+ private Map<Component, Alignment> componentToAlignment = new HashMap<Component, Alignment>();
/**
* Is spacing between contained components enabled. Defaults to false.
*/
private boolean spacing = false;
- private static final int ALIGNMENT_DEFAULT = ALIGNMENT_TOP + ALIGNMENT_LEFT;
+ private static final Alignment ALIGNMENT_DEFAULT = Alignment.TOP_LEFT;
/**
* Has there been rows inserted or deleted in the middle of the layout since
area.getComponent().paint(target);
alignmentsArray[index++] = String
- .valueOf(getComponentAlignment(area.getComponent()));
+ .valueOf(getComponentAlignment(area.getComponent())
+ .getBitMask());
target.endTag("gc");
* com.itmill.toolkit.ui.Layout.AlignmentHandler#getComponentAlignment(com
* .itmill.toolkit.ui.Component)
*/
- public int getComponentAlignment(Component childComponent) {
- final Integer bitMask = (Integer) componentToAlignment
- .get(childComponent);
- if (bitMask != null) {
- return bitMask.intValue();
- } else {
+ public Alignment getComponentAlignment(Component childComponent) {
+ Alignment alignment = componentToAlignment.get(childComponent);
+ if (alignment == null) {
return ALIGNMENT_DEFAULT;
+ } else {
+ return alignment;
}
}
*/
public void setComponentAlignment(Component childComponent,
int horizontalAlignment, int verticalAlignment) {
- componentToAlignment.put(childComponent, new Integer(
+ componentToAlignment.put(childComponent, new Alignment(
horizontalAlignment + verticalAlignment));
requestRepaint();
}
+ public void setComponentAlignment(Component childComponent,
+ Alignment alignment) {
+ componentToAlignment.put(childComponent, alignment);
+ requestRepaint();
+ }
+
/*
* (non-Javadoc)
*
package com.itmill.toolkit.ui;
-import com.itmill.toolkit.terminal.gwt.client.ui.AlignmentInfo;
import com.itmill.toolkit.terminal.gwt.client.ui.IMarginInfo;
+import com.itmill.toolkit.terminal.gwt.client.ui.AlignmentInfo.Bits;
/**
* Extension to the {@link ComponentContainer} interface which adds the
boolean left);
/**
- * TODO make javadocs, remove from implementing classes
+ * AlignmentHandler is most commonly an advanced {@link Layout} that can
+ * align its components.
*/
public interface AlignmentHandler {
/**
* Contained component should be aligned horizontally to the left.
+ *
+ * @deprecated Use of {@link Alignment} class and its constants
*/
- public static final int ALIGNMENT_LEFT = AlignmentInfo.ALIGNMENT_LEFT;
+ @Deprecated
+ public static final int ALIGNMENT_LEFT = Bits.ALIGNMENT_LEFT;
/**
* Contained component should be aligned horizontally to the right.
+ *
+ * @deprecated Use of {@link Alignment} class and its constants
*/
- public static final int ALIGNMENT_RIGHT = AlignmentInfo.ALIGNMENT_RIGHT;
+ @Deprecated
+ public static final int ALIGNMENT_RIGHT = Bits.ALIGNMENT_RIGHT;
/**
* Contained component should be aligned vertically to the top.
+ *
+ * @deprecated Use of {@link Alignment} class and its constants
*/
- public static final int ALIGNMENT_TOP = AlignmentInfo.ALIGNMENT_TOP;
+ @Deprecated
+ public static final int ALIGNMENT_TOP = Bits.ALIGNMENT_TOP;
/**
* Contained component should be aligned vertically to the bottom.
+ *
+ * @deprecated Use of {@link Alignment} class and its constants
*/
- public static final int ALIGNMENT_BOTTOM = AlignmentInfo.ALIGNMENT_BOTTOM;
+ @Deprecated
+ public static final int ALIGNMENT_BOTTOM = Bits.ALIGNMENT_BOTTOM;
/**
* Contained component should be horizontally aligned to center.
+ *
+ * @deprecated Use of {@link Alignment} class and its constants
*/
- public static final int ALIGNMENT_HORIZONTAL_CENTER = AlignmentInfo.ALIGNMENT_HORIZONTAL_CENTER;
+ @Deprecated
+ public static final int ALIGNMENT_HORIZONTAL_CENTER = Bits.ALIGNMENT_HORIZONTAL_CENTER;
/**
* Contained component should be vertically aligned to center.
+ *
+ * @deprecated Use of {@link Alignment} class and its constants
*/
- public static final int ALIGNMENT_VERTICAL_CENTER = AlignmentInfo.ALIGNMENT_VERTICAL_CENTER;
+ @Deprecated
+ public static final int ALIGNMENT_VERTICAL_CENTER = Bits.ALIGNMENT_VERTICAL_CENTER;
/**
* Set alignment for one contained component in this layout. Alignment
* is calculated as a bit mask of the two passed values.
*
+ * @deprecated Use {@link #setComponentAlignment(Component, Alignment)}
+ * instead
+ *
* @param childComponent
* the component to align within it's layout cell.
* @param horizontalAlignment
* the vertical alignment for the child component (top,
* center, bottom). Use ALIGNMENT constants.
*/
+ @Deprecated
public void setComponentAlignment(Component childComponent,
int horizontalAlignment, int verticalAlignment);
/**
+ * Set alignment for one contained component in this layout. Use
+ * predefined alignments from Alignment class.
+ *
+ * Example: <code>
+ * layout.setComponentAlignment(myComponent, Alignment.TOP_RIGHT);
+ * </code>
*
* @param childComponent
- * @return
+ * the component to align within it's layout cell.
+ * @param alignment
+ * the Alignment value to be set
*/
- public int getComponentAlignment(Component childComponent);
+ public void setComponentAlignment(Component childComponent,
+ Alignment alignment);
+
+ /**
+ * Returns the current Alignment of given component.
+ *
+ * @param childComponent
+ * @return the {@link Alignment}
+ */
+ public Alignment getComponentAlignment(Component childComponent);
}
/**
* This type of layout can enable margins.
- *
- * TODO refine javadocs
*/
public interface MarginHandler {
/**
projects / vaadin-framework.git / commitdiff