/*
* Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (miglayout (at) miginfocom (dot) com),
* modifications by Nikolaus Moll
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
* Neither the name of the MiG InfoCom AB nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
* @version 1.0
* @author Mikael Grev, MiG InfoCom AB
* Date: 2006-sep-08
*/
package org.jowidgets.impl.layout.miglayout;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.ObjectStreamException;
import java.util.ArrayList;
/**
* A simple value holder for one component's constraint.
*/
final class CCCommon implements Externalizable {
static final String[] DOCK_SIDES = {"north", "west", "south", "east"};
private static final BoundSizeCommon DEF_GAP = BoundSizeCommon.NULL_SIZE; // Only used to denote default wrap/newline gap.
private static final String[] EMPTY_ARR = new String[0];
// See the getters and setters for information about the properties below.
private int dock = -1;
private UnitValueCommon[] pos = null; // [x1, y1, x2, y2]
private UnitValueCommon[] padding = null; // top, left, bottom, right
private Boolean flowX = null;
private int skip = 0;
private int split = 1;
private int spanX = 1;
private int spanY = 1;
private int cellX = -1;
private int cellY = 0; // If cellX is -1 then cellY is also considered -1. cellY is never negative.
private String tag = null;
private String id = null;
private int hideMode = -1;
private DimConstraintCommon hor = new DimConstraintCommon();
private DimConstraintCommon ver = new DimConstraintCommon();
private BoundSizeCommon newline = null;
private BoundSizeCommon wrap = null;
private boolean boundsInGrid = true;
private boolean external = false;
private Float pushX = null;
private Float pushY = null;
private transient String[] linkTargets = null;
//private final LayoutUtil layoutUtil;
/**
* Empty constructor.
*/
CCCommon() {}
String[] getLinkTargets() {
if (linkTargets == null) {
final ArrayList<String> targets = new ArrayList<String>(2);
if (pos != null) {
for (int i = 0; i < pos.length; i++) {
addLinkTargetIDs(targets, pos[i]);
}
}
linkTargets = targets.size() == 0 ? EMPTY_ARR : targets.toArray(new String[targets.size()]);
}
return linkTargets;
}
private void addLinkTargetIDs(final ArrayList<String> targets, final UnitValueCommon uv) {
if (uv != null) {
final String linkId = uv.getLinkTargetId();
if (linkId != null) {
targets.add(linkId);
}
else {
for (int i = uv.getSubUnitCount() - 1; i >= 0; i--) {
final UnitValueCommon subUv = uv.getSubUnitValue(i);
if (subUv.isLinkedDeep()) {
addLinkTargetIDs(targets, subUv);
}
}
}
}
}
// **********************************************************
// Chaining constraint setters
// **********************************************************
/**
* Specifies that the component should be put in the end group <code>s</code> and will thus share the same ending
* coordinate as them within the group.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param s A name to associate on the group that should be the same for other rows/columns in the same group.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon endGroupX(final String s) {
hor.setEndGroup(s);
return this;
}
/**
* Specifies that the component should be put in the size group <code>s</code> and will thus share the same size
* as them within the group.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param s A name to associate on the group that should be the same for other rows/columns in the same group.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon sizeGroupX(final String s) {
hor.setSizeGroup(s);
return this;
}
/**
* The minimum size for the component. The value will override any value that is set on the component itself.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param size The size expressed as a <code>UnitValue</code>. E.g. "100px" or "200mm".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon minWidth(final String size) {
hor.setSize(MigLayoutToolkitImpl.getMigLayoutUtil().derive(
hor.getSize(),
ConstraintParserCommon.parseUnitValue(size, true),
null,
null));
return this;
}
/**
* The size for the component as a min and/or preferref and/or maximum size. The value will override any value that is set on
* the component itself.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param size The size expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon width(final String size) {
hor.setSize(ConstraintParserCommon.parseBoundSize(size, false, true));
return this;
}
/**
* The maximum size for the component. The value will override any value that is set on the component itself.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param size The size expressed as a <code>UnitValue</code>. E.g. "100px" or "200mm".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon maxWidth(final String size) {
hor.setSize(MigLayoutToolkitImpl.getMigLayoutUtil().derive(
hor.getSize(),
null,
null,
ConstraintParserCommon.parseUnitValue(size, true)));
return this;
}
/**
* The horizontal gap before and/or after the component. The gap is towards cell bounds and/or other component bounds.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param before The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @param after The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon gapX(final String before, final String after) {
if (before != null) {
hor.setGapBefore(ConstraintParserCommon.parseBoundSize(before, true, true));
}
if (after != null) {
hor.setGapAfter(ConstraintParserCommon.parseBoundSize(after, true, true));
}
return this;
}
/**
* Same functionality as <code>getHorizontal().setAlign(ConstraintParser.parseUnitValue(unitValue, true))</code> only this
* method
* returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param align The align keyword or for instance "100px". E.g "left", "right", "leading" or "trailing".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon alignX(final String align) {
hor.setAlign(ConstraintParserCommon.parseUnitValueOrAlign(align, true, null));
return this;
}
/**
* The grow priority compared to other components in the same cell.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param p The grow priority.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon growPrioX(final int p) {
hor.setGrowPriority(p);
return this;
}
/**
* Grow priority for the component horizontally and optionally vertically.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param widthHeight The new shrink weight and height. 1-2 arguments, never null.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon growPrio(final int... widthHeight) {
switch (widthHeight.length) {
case 1:
growPrioX(widthHeight[0]);
break;
case 2:
growPrioY(widthHeight[1]);
growPrioX(widthHeight[0]);
break;
default:
throw new IllegalArgumentException("Illegal argument count: " + widthHeight.length);
}
return this;
}
/**
* Grow weight for the component horizontally. It default to weight <code>100</code>.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #growX(float)
*/
public CCCommon growX() {
hor.setGrow(ResizeConstraintCommon.WEIGHT_100);
return this;
}
/**
* Grow weight for the component horizontally.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param w The new grow weight.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon growX(final float w) {
hor.setGrow(new Float(w));
return this;
}
/**
* grow weight for the component horizontally and optionally vertically.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param widthHeight The new shrink weight and height. 1-2 arguments, never null.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon grow(final float... widthHeight) {
switch (widthHeight.length) {
case 1:
growX(widthHeight[0]);
break;
case 2:
growY(widthHeight[1]);
growX(widthHeight[0]);
break;
default:
throw new IllegalArgumentException("Illegal argument count: " + widthHeight.length);
}
return this;
}
/**
* The shrink priority compared to other components in the same cell.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param p The shrink priority.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon shrinkPrioX(final int p) {
hor.setShrinkPriority(p);
return this;
}
/**
* Shrink priority for the component horizontally and optionally vertically.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param widthHeight The new shrink weight and height. 1-2 arguments, never null.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon shrinkPrio(final int... widthHeight) {
switch (widthHeight.length) {
case 1:
shrinkPrioX(widthHeight[0]);
break;
case 2:
shrinkPrioY(widthHeight[1]);
shrinkPrioX(widthHeight[0]);
break;
default:
throw new IllegalArgumentException("Illegal argument count: " + widthHeight.length);
}
return this;
}
/**
* Shrink weight for the component horizontally.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param w The new shrink weight.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon shrinkX(final float w) {
hor.setShrink(new Float(w));
return this;
}
/**
* Shrink weight for the component horizontally and optionally vertically.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param widthHeight The new shrink weight and height. 1-2 arguments, never null.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon shrink(final float... widthHeight) {
switch (widthHeight.length) {
case 2:
shrinkY(widthHeight[1]);
shrinkX(widthHeight[0]);
break;
case 1:
shrinkX(widthHeight[0]);
break;
default:
throw new IllegalArgumentException("Illegal argument count: " + widthHeight.length);
}
return this;
}
/**
* The end group that this component should be placed in.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param s The name of the group. If <code>null</code> that means no group (default)
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon endGroupY(final String s) {
ver.setEndGroup(s);
return this;
}
/**
* The end group(s) that this component should be placed in.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param xy The end group for x and y respectively. 1-2 arguments, not null.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon endGroup(final String... xy) {
switch (xy.length) {
case 1:
endGroupX(xy[0]);
break;
case 2:
endGroupY(xy[1]);
endGroupX(xy[0]);
break;
default:
throw new IllegalArgumentException("Illegal argument count: " + xy.length);
}
return this;
}
/**
* The size group that this component should be placed in.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param s The name of the group. If <code>null</code> that means no group (default)
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon sizeGroupY(final String s) {
ver.setSizeGroup(s);
return this;
}
/**
* The size group(s) that this component should be placed in.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param xy The size group for x and y respectively. 1-2 arguments, not null.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon sizeGroup(final String... xy) {
switch (xy.length) {
case 1:
sizeGroupX(xy[0]);
break;
case 2:
sizeGroupY(xy[1]);
sizeGroupX(xy[0]);
break;
default:
throw new IllegalArgumentException("Illegal argument count: " + xy.length);
}
return this;
}
/**
* The minimum size for the component. The value will override any value that is set on the component itself.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param size The size expressed as a <code>UnitValue</code>. E.g. "100px" or "200mm".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon minHeight(final String size) {
ver.setSize(MigLayoutToolkitImpl.getMigLayoutUtil().derive(
ver.getSize(),
ConstraintParserCommon.parseUnitValue(size, false),
null,
null));
return this;
}
/**
* The size for the component as a min and/or preferred and/or maximum size. The value will override any value that is set on
* the component itself.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param size The size expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon height(final String size) {
ver.setSize(ConstraintParserCommon.parseBoundSize(size, false, false));
return this;
}
/**
* The maximum size for the component. The value will override any value that is set on the component itself.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param size The size expressed as a <code>UnitValue</code>. E.g. "100px" or "200mm".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon maxHeight(final String size) {
ver.setSize(MigLayoutToolkitImpl.getMigLayoutUtil().derive(
ver.getSize(),
null,
null,
ConstraintParserCommon.parseUnitValue(size, false)));
return this;
}
/**
* The vertical gap before (normally above) and/or after (normally below) the component. The gap is towards cell bounds and/or
* other component bounds.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param before The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @param after The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon gapY(final String before, final String after) {
if (before != null) {
ver.setGapBefore(ConstraintParserCommon.parseBoundSize(before, true, false));
}
if (after != null) {
ver.setGapAfter(ConstraintParserCommon.parseBoundSize(after, true, false));
}
return this;
}
/**
* Same functionality as <code>getVertical().setAlign(ConstraintParser.parseUnitValue(unitValue, true))</code> only this
* method
* returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param align The align keyword or for instance "100px". E.g "top" or "bottom".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon alignY(final String align) {
ver.setAlign(ConstraintParserCommon.parseUnitValueOrAlign(align, false, null));
return this;
}
/**
* The grow priority compared to other components in the same cell.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param p The grow priority.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon growPrioY(final int p) {
ver.setGrowPriority(p);
return this;
}
/**
* Grow weight for the component vertically. Defaults to <code>100</code>.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #growY(Float)
*/
public CCCommon growY() {
ver.setGrow(ResizeConstraintCommon.WEIGHT_100);
return this;
}
/**
* Grow weight for the component vertically.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param w The new grow weight.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon growY(final Float w) {
ver.setGrow(w);
return this;
}
/**
* The shrink priority compared to other components in the same cell.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param p The shrink priority.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon shrinkPrioY(final int p) {
ver.setShrinkPriority(p);
return this;
}
/**
* Shrink weight for the component horizontally.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param w The new shrink weight.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon shrinkY(final float w) {
ver.setShrink(new Float(w));
return this;
}
/**
* How this component, if hidden (not visible), should be treated.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param mode The mode. Default to the mode in the {@link LCCommon.miginfocom.layout.LC}.
* 0 == Normal. Bounds will be calculated as if the component was visible.<br>
* 1 == If hidden the size will be 0, 0 but the gaps remain.<br>
* 2 == If hidden the size will be 0, 0 and gaps set to zero.<br>
* 3 == If hidden the component will be disregarded completely and not take up a cell in the grid..
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon hideMode(final int mode) {
setHideMode(mode);
return this;
}
/**
* The id used to reference this component in some constraints.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param s The id or <code>null</code>. May consist of a groupID and an componentID which are separated by a dot: ".". E.g.
* "grp1.id1".
* The dot should never be first or last if present.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
*/
public CCCommon id(final String s) {
setId(s);
return this;
}
/**
* Same functionality as {@link #setTag(String tag)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param tag The new tag. May be <code>null</code>.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setTag(String)
*/
public CCCommon tag(final String tag) {
setTag(tag);
return this;
}
/**
* Set the cell(s) that the component should occupy in the grid. Same functionality as {@link #setCellX(int col)} and
* {@link #setCellY(int row)} together with {@link #setSpanX(int width)} and {@link #setSpanY(int height)}. This method
* returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param colRowWidthHeight cellX, cellY, spanX, spanY repectively. 1-4 arguments, not null.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setCellX(int)
* @see #setCellY(int)
* @see #setSpanX(int)
* @see #setSpanY(int)
* @since 3.7.2. Replacing cell(int, int) and cell(int, int, int, int)
*/
public CCCommon cell(final int... colRowWidthHeight) {
if ((colRowWidthHeight.length > 4) || (colRowWidthHeight.length < 1)) {
throw new IllegalArgumentException("Illegal argument count: " + colRowWidthHeight.length);
}
if (colRowWidthHeight.length > 3) {
setSpanY(colRowWidthHeight[3]);
}
if (colRowWidthHeight.length > 2) {
setSpanX(colRowWidthHeight[2]);
}
if (colRowWidthHeight.length > 1) {
setCellY(colRowWidthHeight[1]);
}
setCellX(colRowWidthHeight[0]);
return this;
}
/**
* Same functionality as <code>spanX(cellsX).spanY(cellsY)</code> which means this cell will span cells in both x and y.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
* Since 3.7.2 this takes an array/vararg whereas it previously only took two specific values, xSpan and ySpan.
*
* @param cells spanX and spanY, when present, and in that order.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setSpanY(int)
* @see #setSpanX(int)
* @see #spanY()
* @see #spanX()
* @since 3.7.2 Replaces span(int, int).
*/
public CCCommon span(final int... cells) {
if (cells == null || cells.length == 0) {
setSpanX(LayoutUtilCommon.INF);
setSpanY(1);
}
else if (cells.length == 1) {
setSpanX(cells[0]);
setSpanY(1);
}
else {
setSpanX(cells[0]);
setSpanY(cells[1]);
}
return this;
}
/**
* Corresponds exactly to the "gap left right top bottom" keyword.
*
* @param args Same as for the "gap" keyword. Length 1-4, never null buf elements can be null.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gap(final String... args) {
if ((args.length > 4) || (args.length < 1)) {
throw new IllegalArgumentException("Illegal argument count: " + args.length);
}
if (args.length > 3) {
gapBottom(args[3]);
}
if (args.length > 2) {
gapTop(args[2]);
}
if (args.length > 1) {
gapRight(args[1]);
}
gapLeft(args[0]);
return this;
}
/**
* Sets the horizontal gap before the component.
* <p>
* Note! This is currently same as gapLeft(). This might change in 4.x.
*
* @param boundsSize The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gapBefore(final String boundsSize) {
hor.setGapBefore(ConstraintParserCommon.parseBoundSize(boundsSize, true, true));
return this;
}
/**
* Sets the horizontal gap after the component.
* <p>
* Note! This is currently same as gapLeft(). This might change in 4.x.
*
* @param boundsSize The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gapAfter(final String boundsSize) {
hor.setGapAfter(ConstraintParserCommon.parseBoundSize(boundsSize, true, true));
return this;
}
/**
* Sets the gap above the component.
*
* @param boundsSize The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gapTop(final String boundsSize) {
ver.setGapBefore(ConstraintParserCommon.parseBoundSize(boundsSize, true, false));
return this;
}
/**
* Sets the gap to the left of the component.
*
* @param boundsSize The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gapLeft(final String boundsSize) {
hor.setGapBefore(ConstraintParserCommon.parseBoundSize(boundsSize, true, true));
return this;
}
/**
* Sets the gap below the component.
*
* @param boundsSize The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gapBottom(final String boundsSize) {
ver.setGapAfter(ConstraintParserCommon.parseBoundSize(boundsSize, true, false));
return this;
}
/**
* Sets the gap to the right of the component.
*
* @param boundsSize The size of the gap expressed as a <code>BoundSize</code>. E.g. "50:100px:200mm" or "100px!".
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @since 3.7.2
*/
public CCCommon gapRight(final String boundsSize) {
hor.setGapAfter(ConstraintParserCommon.parseBoundSize(boundsSize, true, true));
return this;
}
/**
* Same functionality as {@link #setSpanY(int)} which means this cell will span the rest of the column.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setSpanY(int)
* @see #spanY()
*/
public CCCommon spanY() {
return spanY(LayoutUtilCommon.INF);
}
/**
* Same functionality as {@link #setSpanY(int)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param cells The number of cells to span (i.e. merge).
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setSpanY(int)
*/
public CCCommon spanY(final int cells) {
setSpanY(cells);
return this;
}
/**
* Same functionality as {@link #setSpanX(int)} which means this cell will span the rest of the row.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setSpanX(int)
* @see #spanX()
*/
public CCCommon spanX() {
return spanX(LayoutUtilCommon.INF);
}
/**
* Same functionality as {@link #setSpanX(int)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param cells The number of cells to span (i.e. merge).
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setSpanY(int)
*/
public CCCommon spanX(final int cells) {
setSpanX(cells);
return this;
}
/**
* Same functionality as <code>pushX().pushY()</code> which means this cell will push in both x and y dimensions.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setPushX(Float)
* @see #setPushX(Float)
* @see #pushY()
* @see #pushX()
*/
public CCCommon push() {
return pushX().pushY();
}
/**
* Same functionality as <code>pushX(weightX).pushY(weightY)</code> which means this cell will push in both x and y
* dimensions.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param weightX The weight used in the push.
* @param weightY The weight used in the push.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setPushY(Float)
* @see #setPushX(Float)
* @see #pushY()
* @see #pushX()
*/
public CCCommon push(final Float weightX, final Float weightY) {
return pushX(weightX).pushY(weightY);
}
/**
* Same functionality as {@link #setPushY(Float))} which means this cell will push the rest of the column.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setPushY(Float)
*/
public CCCommon pushY() {
return pushY(ResizeConstraintCommon.WEIGHT_100);
}
/**
* Same functionality as {@link #setPushY(Float weight)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param weight The weight used in the push.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setPushY(Float)
*/
public CCCommon pushY(final Float weight) {
setPushY(weight);
return this;
}
/**
* Same functionality as {@link #setPushX(Float)} which means this cell will push the rest of the row.
* This method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setPushX(Float)
*/
public CCCommon pushX() {
return pushX(ResizeConstraintCommon.WEIGHT_100);
}
/**
* Same functionality as {@link #setPushX(Float weight)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param weight The weight used in the push.
* @return <code>this</code> so it is possible to chain calls. E.g. <code>new LayoutConstraint().noGrid().gap().fill()</code>.
* @see #setPushY(Float)
*/
public CCCommon pushX(final Float weight) {
setPushX(weight);
return this;
}
/**
* Same functionality as {@link #setSplit(int parts)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param parts The number of parts (i.e. component slots) the cell should be divided into.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setSplit(int)
*/
public CCCommon split(final int parts) {
setSplit(parts);
return this;
}
/**
* Same functionality as split(LayoutUtil.INF), which means split until one of the keywords that breaks the split is found for
* a component after this one (e.g. wrap, newline and skip).
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setSplit(int)
* @since 3.7.2
*/
public CCCommon split() {
setSplit(LayoutUtilCommon.INF);
return this;
}
/**
* Same functionality as {@link #setSkip(int)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param cells How many cells in the grid that should be skipped <b>before</b> the component that this constraint belongs to
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setSkip(int)
*/
public CCCommon skip(final int cells) {
setSkip(cells);
return this;
}
/**
* Same functionality as skip(1).
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setSkip(int)
* @since 3.7.2
*/
public CCCommon skip() {
setSkip(1);
return this;
}
/**
* Same functionality as {@link #setExternal(boolean true)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setExternal(boolean)
*/
public CCCommon external() {
setExternal(true);
return this;
}
/**
* Same functionality as {@link #setFlowX(Boolean .TRUE)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setFlowX(Boolean)
*/
public CCCommon flowX() {
setFlowX(Boolean.TRUE);
return this;
}
/**
* Same functionality as {@link #setFlowX(Boolean .FALSE)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setFlowX(Boolean)
*/
public CCCommon flowY() {
setFlowX(Boolean.FALSE);
return this;
}
/**
* Same functionality as {@link #growX()} and {@link #growY()}.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #growX()
* @see #growY()
*/
public CCCommon grow() {
growX();
growY();
return this;
}
/**
* Same functionality as {@link #setNewline(boolean true)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setNewline(boolean)
*/
public CCCommon newline() {
setNewline(true);
return this;
}
/**
* Same functionality as {@link #setNewlineGapSize(BoundSizeCommon)} only this method returns <code>this</code> for chaining
* multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param gapSize The gap size that will override the gap size in the row/colum constraints if <code>!= null</code>. E.g.
* "5px" or "unrel".
* If <code>null</code> or <code>""</code> the newline size will be set to the default size and turned on. This is
* different compared to {@link #setNewlineGapSize(BoundSizeCommon)}.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setNewlineGapSize(BoundSizeCommon)
*/
public CCCommon newline(final String gapSize) {
final BoundSizeCommon bs = ConstraintParserCommon.parseBoundSize(gapSize, true, (flowX != null && flowX == false));
if (bs != null) {
setNewlineGapSize(bs);
}
else {
setNewline(true);
}
return this;
}
/**
* Same functionality as {@link #setWrap(boolean true)} only this method returns <code>this</code> for chaining multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setWrap(boolean)
*/
public CCCommon wrap() {
setWrap(true);
return this;
}
/**
* Same functionality as {@link #setWrapGapSize(BoundSizeCommon)} only this method returns <code>this</code> for chaining
* multiple
* calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param gapSize The gap size that will override the gap size in the row/colum constraints if <code>!= null</code>. E.g.
* "5px" or "unrel".
* If <code>null</code> or <code>""</code> the wrap size will be set to the default size and turned on. This is
* different compared to {@link #setWrapGapSize(BoundSizeCommon)}.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setWrapGapSize(BoundSizeCommon)
*/
public CCCommon wrap(final String gapSize) {
final BoundSizeCommon bs = ConstraintParserCommon.parseBoundSize(gapSize, true, (flowX != null && flowX == false));
if (bs != null) {
setWrapGapSize(bs);
}
else {
setWrap(true);
}
return this;
}
/**
* Same functionality as {@link #setDockSide(int 0)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setDockSide(int)
*/
public CCCommon dockNorth() {
setDockSide(0);
return this;
}
/**
* Same functionality as {@link #setDockSide(int 1)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setDockSide(int)
*/
public CCCommon dockWest() {
setDockSide(1);
return this;
}
/**
* Same functionality as {@link #setDockSide(int 2)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setDockSide(int)
*/
public CCCommon dockSouth() {
setDockSide(2);
return this;
}
/**
* Same functionality as {@link #setDockSide(int 3)} only this method returns <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setDockSide(int)
*/
public CCCommon dockEast() {
setDockSide(3);
return this;
}
/**
* Sets the x-coordinate for the component. This is used to set the x coordinate position to a specific value. The component
* bounds is still precalculated to the grid cell and this method should be seen as a way to correct the x position.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param x The x position as a UnitValue. E.g. "10" or "40mm" or "container.x+10".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setPos(UnitValueCommon[])
* @see #setBoundsInGrid(boolean)
*/
public CCCommon x(final String x) {
return corrPos(x, 0);
}
/**
* Sets the y-coordinate for the component. This is used to set the y coordinate position to a specific value. The component
* bounds is still precalculated to the grid cell and this method should be seen as a way to correct the y position.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param y The y position as a UnitValue. E.g. "10" or "40mm" or "container.x+10".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setPos(UnitValueCommon[])
* @see #setBoundsInGrid(boolean)
*/
public CCCommon y(final String y) {
return corrPos(y, 1);
}
/**
* Sets the x2-coordinate for the component (right side). This is used to set the x2 coordinate position to a specific value.
* The component
* bounds is still precalculated to the grid cell and this method should be seen as a way to correct the x position.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param x2 The x2 side's position as a UnitValue. E.g. "10" or "40mm" or "container.x2 - 10".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setPos(UnitValueCommon[])
* @see #setBoundsInGrid(boolean)
*/
public CCCommon x2(final String x2) {
return corrPos(x2, 2);
}
/**
* Sets the y2-coordinate for the component (bottom side). This is used to set the y2 coordinate position to a specific value.
* The component
* bounds is still precalculated to the grid cell and this method should be seen as a way to correct the y position.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param y2 The y2 side's position as a UnitValue. E.g. "10" or "40mm" or "container.x2 - 10".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setPos(UnitValueCommon[])
* @see #setBoundsInGrid(boolean)
*/
public CCCommon y2(final String y2) {
return corrPos(y2, 3);
}
private CCCommon corrPos(final String uv, final int ix) {
UnitValueCommon[] b = getPos();
if (b == null) {
b = new UnitValueCommon[4];
}
b[ix] = ConstraintParserCommon.parseUnitValue(uv, (ix % 2 == 0));
setPos(b);
setBoundsInGrid(true);
return this;
}
/**
* Same functionality as {@link #x(String x)} and {@link #y(String y)} toghether.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param x The x position as a UnitValue. E.g. "10" or "40mm" or "container.x+10".
* @param y The y position as a UnitValue. E.g. "10" or "40mm" or "container.x+10".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setPos(UnitValueCommon[])
*/
public CCCommon pos(final String x, final String y) {
UnitValueCommon[] b = getPos();
if (b == null) {
b = new UnitValueCommon[4];
}
b[0] = ConstraintParserCommon.parseUnitValue(x, true);
b[1] = ConstraintParserCommon.parseUnitValue(y, false);
setPos(b);
setBoundsInGrid(false);
return this;
}
/**
* Same functionality as {@link #x(String x)}, {@link #y(String y)}, {@link #y2(String y)} and {@link #y2(String y)}
* toghether.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param x The x position as a UnitValue. E.g. "10" or "40mm" or "container.x+10".
* @param y The y position as a UnitValue. E.g. "10" or "40mm" or "container.x+10".
* @param x2 The x2 side's position as a UnitValue. E.g. "10" or "40mm" or "container.x2 - 10".
* @param y2 The y2 side's position as a UnitValue. E.g. "10" or "40mm" or "container.x2 - 10".
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setPos(UnitValueCommon[])
*/
public CCCommon pos(final String x, final String y, final String x2, final String y2) {
setPos(new UnitValueCommon[] {
ConstraintParserCommon.parseUnitValue(x, true), ConstraintParserCommon.parseUnitValue(y, false),
ConstraintParserCommon.parseUnitValue(x2, true), ConstraintParserCommon.parseUnitValue(y2, false),});
setBoundsInGrid(false);
return this;
}
/**
* Same functionality as {@link #setPadding(UnitValueCommon[])} but the unit values as absolute pixels. This method returns
* <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param top The top padding that will be added to the y coordinate at the last stage in the layout.
* @param left The top padding that will be added to the x coordinate at the last stage in the layout.
* @param bottom The top padding that will be added to the y2 coordinate at the last stage in the layout.
* @param right The top padding that will be added to the x2 coordinate at the last stage in the layout.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setTag(String)
*/
public CCCommon pad(final int top, final int left, final int bottom, final int right) {
setPadding(new UnitValueCommon[] {
new UnitValueCommon(top), new UnitValueCommon(left), new UnitValueCommon(bottom), new UnitValueCommon(right)});
return this;
}
/**
* Same functionality as <code>setPadding(ConstraintParser.parseInsets(pad, false))}</code> only this method returns
* <code>this</code> for chaining multiple calls.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param pad The string to parse. E.g. "10 10 10 10" or "20". If less than 4 groups the last will be used for the missing.
* @return <code>this</code> so it is possible to chain calls. E.g.
* <code>new ComponentConstraint().noGrid().gap().fill()</code>.
* @see #setTag(String)
*/
public CCCommon pad(final String pad) {
setPadding(pad != null ? ConstraintParserCommon.parseInsets(pad, false) : null);
return this;
}
// **********************************************************
// Bean properties
// **********************************************************
/**
* Returns the horizontal dimension constraint for this component constraint. It has constraints for the horizontal size
* and grow/shrink priorities and weights.
* <p>
* Note! If any changes is to be made it must be made direct when the object is returned. It is not allowed to save the
* constraint for later use.
*
* @return The current dimension constraint. Never <code>null</code>.
*/
public DimConstraintCommon getHorizontal() {
return hor;
}
/**
* Sets the horizontal dimension constraint for this component constraint. It has constraints for the horizontal size
* and grow/shrink priorities and weights.
*
* @param h The new dimension constraint. If <code>null</code> it will be reset to <code>new DimConstraint();</code>
*/
public void setHorizontal(final DimConstraintCommon h) {
hor = h != null ? h : new DimConstraintCommon();
}
/**
* Returns the vertical dimension constraint for this component constraint. It has constraints for the vertical size
* and grow/shrink priorities and weights.
* <p>
* Note! If any changes is to be made it must be made direct when the object is returned. It is not allowed to save the
* constraint for later use.
*
* @return The current dimension constraint. Never <code>null</code>.
*/
public DimConstraintCommon getVertical() {
return ver;
}
/**
* Sets the vertical dimension constraint for this component constraint. It has constraints for the vertical size
* and grow/shrink priorities and weights.
*
* @param v The new dimension constraint. If <code>null</code> it will be reset to <code>new DimConstraint();</code>
*/
public void setVertical(final DimConstraintCommon v) {
ver = v != null ? v : new DimConstraintCommon();
}
/**
* Returns the vertical or horizontal dim constraint.
* <p>
* Note! If any changes is to be made it must be made direct when the object is returned. It is not allowed to save the
* constraint for later use.
*
* @param isHor If the horizontal constraint should be returned.
* @return The dim constraint. Never <code>null</code>.
*/
public DimConstraintCommon getDimConstraint(final boolean isHor) {
return isHor ? hor : ver;
}
/**
* Returns the absolute positioning of one or more of the edges. This will be applied last in the layout cycle and will not
* affect the flow or grid positions. The positioning is relative to the parent and can not (as padding) be used
* to adjust the edges relative to the old value. May be <code>null</code> and elements may be <code>null</code>.
* <code>null</code> value(s) for the x2 and y2 will be interpreted as to keep the preferred size and thus the x1
* and x2 will just absolutely positions the component.
* <p>
* Note that {@link #setBoundsInGrid(boolean)} changes the interpretation of thisproperty slightly.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value as a new array, free to modify.
*/
public UnitValueCommon[] getPos() {
return pos != null ? new UnitValueCommon[] {pos[0], pos[1], pos[2], pos[3]} : null;
}
/**
* Sets absolute positioning of one or more of the edges. This will be applied last in the layout cycle and will not
* affect the flow or grid positions. The positioning is relative to the parent and can not (as padding) be used
* to adjust the edges relative to the old value. May be <code>null</code> and elements may be <code>null</code>.
* <code>null</code> value(s) for the x2 and y2 will be interpreted as to keep the preferred size and thus the x1
* and x2 will just absolutely positions the component.
* <p>
* Note that {@link #setBoundsInGrid(boolean)} changes the interpretation of thisproperty slightly.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param pos <code>UnitValue[] {x, y, x2, y2}</code>. Must be <code>null</code> or of length 4. Elements can be
* <code>null</code>.
*/
public void setPos(final UnitValueCommon[] pos) {
this.pos = pos != null ? new UnitValueCommon[] {pos[0], pos[1], pos[2], pos[3]} : null;
linkTargets = null;
}
/**
* Returns if the absolute <code>pos</code> value should be corrections to the component that is in a normal cell. If
* <code>false</code> the value of <code>pos</code> is truly absolute in that it will not affect the grid or have a default
* bounds in the grid.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
* @see #getPos()
*/
public boolean isBoundsInGrid() {
return boundsInGrid;
}
/**
* Sets if the absolute <code>pos</code> value should be corrections to the component that is in a normal cell. If
* <code>false</code> the value of <code>pos</code> is truly absolute in that it will not affect the grid or have a default
* bounds in the grid.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param b <code>true</code> for bounds taken from the grid position. <code>false</code> is default.
* @see #setPos(UnitValueCommon[])
*/
void setBoundsInGrid(final boolean b) {
this.boundsInGrid = b;
}
/**
* Returns the absolute cell position in the grid or <code>-1</code> if cell positioning is not used.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public int getCellX() {
return cellX;
}
/**
* Set an absolute cell x-position in the grid. If >= 0 this point points to the absolute cell that this constaint's
* component should occupy.
* If there's already a component in that cell they will split the cell. The flow will then continue after this cell.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param x The x-position or <code>-1</code> to disable cell positioning.
*/
public void setCellX(final int x) {
cellX = x;
}
/**
* Returns the absolute cell position in the grid or <code>-1</code> if cell positioning is not used.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public int getCellY() {
return cellX < 0 ? -1 : cellY;
}
/**
* Set an absolute cell x-position in the grid. If >= 0 this point points to the absolute cell that this constaint's
* component should occupy.
* If there's already a component in that cell they will split the cell. The flow will then continue after this cell.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param y The y-position or <code>-1</code> to disable cell positioning.
*/
public void setCellY(final int y) {
if (y < 0) {
cellX = -1;
}
cellY = y < 0 ? 0 : y;
}
/**
* Sets the docking side. -1 means no docking.<br>
* Valid sides are: <code> north = 0, west = 1, south = 2, east = 3</code>.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current side.
*/
public int getDockSide() {
return dock;
}
/**
* Sets the docking side. -1 means no docking.<br>
* Valid sides are: <code> north = 0, west = 1, south = 2, east = 3</code>.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param side -1 or 0-3.
*/
public void setDockSide(final int side) {
if (side < -1 || side > 3) {
throw new IllegalArgumentException("Illegal dock side: " + side);
}
dock = side;
}
/**
* Returns if this component should have its bounds handled by an external source and not this layout manager.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public boolean isExternal() {
return external;
}
/**
* If this boolean is true this component is not handled in any way by the layout manager and the component can have its
* bounds set by an external
* handler which is normally by the use of some <code>component.setBounds(x, y, width, height)</code> directly (for Swing).
* <p>
* The bounds <b>will not</b> affect the minimum and preferred size of the container.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param b <code>true</code> means that the bounds are not changed.
*/
public void setExternal(final boolean b) {
this.external = b;
}
/**
* Returns if the flow in the <b>cell</b> is in the horizontal dimension. Vertical if <code>false</code>. Only the first
* component is a cell can set the flow.
* <p>
* If <code>null</code> the flow direction is inherited by from the {@link LCCommon.miginfocom.layout.LC}.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public Boolean getFlowX() {
return flowX;
}
/**
* Sets if the flow in the <b>cell</b> is in the horizontal dimension. Vertical if <code>false</code>. Only the first
* component is a cell can set the flow.
* <p>
* If <code>null</code> the flow direction is inherited by from the {@link LCCommon.miginfocom.layout.LC}.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param b <code>Boolean.TRUE</code> means horizontal flow in the cell.
*/
public void setFlowX(final Boolean b) {
this.flowX = b;
}
/**
* Sets how a component that is hidden (not visible) should be treated by default.
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The mode:<br>
* 0 == Normal. Bounds will be calculated as if the component was visible.<br>
* 1 == If hidden the size will be 0, 0 but the gaps remain.<br>
* 2 == If hidden the size will be 0, 0 and gaps set to zero.<br>
* 3 == If hidden the component will be disregarded completely and not take up a cell in the grid..
*/
public int getHideMode() {
return hideMode;
}
/**
* Sets how a component that is hidden (not visible) should be treated by default.
*
* @param mode The mode:<br>
* 0 == Normal. Bounds will be calculated as if the component was visible.<br>
* 1 == If hidden the size will be 0, 0 but the gaps remain.<br>
* 2 == If hidden the size will be 0, 0 and gaps set to zero.<br>
* 3 == If hidden the component will be disregarded completely and not take up a cell in the grid..
*/
public void setHideMode(final int mode) {
if (mode < -1 || mode > 3) {
throw new IllegalArgumentException("Wrong hideMode: " + mode);
}
hideMode = mode;
}
/**
* Returns the id used to reference this component in some constraints.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The id or <code>null</code>. May consist of a groupID and an componentID which are separated by a dot: ".". E.g.
* "grp1.id1".
* The dot should never be first or last if present.
*/
public String getId() {
return id;
}
/**
* Sets the id used to reference this component in some constraints.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param id The id or <code>null</code>. May consist of a groupID and an componentID which are separated by a dot: ".". E.g.
* "grp1.id1".
* The dot should never be first or last if present.
*/
public void setId(final String id) {
this.id = id;
}
/**
* Returns the absolute resizing in the last stage of the layout cycle. May be <code>null</code> and elements may be
* <code>null</code>.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value. <code>null</code> or of length 4.
*/
public UnitValueCommon[] getPadding() {
return padding != null ? new UnitValueCommon[] {padding[0], padding[1], padding[2], padding[3]} : null;
}
/**
* Sets the absolute resizing in the last stage of the layout cycle. These values are added to the edges and can thus for
* instance be used to grow or reduce the size or move the component an absolute number of pixels. May be <code>null</code>
* and elements may be <code>null</code>.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param sides top, left, bottom right. Must be <code>null</code> or of length 4.
*/
public void setPadding(final UnitValueCommon[] sides) {
this.padding = sides != null ? new UnitValueCommon[] {sides[0], sides[1], sides[2], sides[3]} : null;
}
/**
* Returns how many cells in the grid that should be skipped <b>before</b> the component that this constraint belongs to.
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value. 0 if no skip.
*/
public int getSkip() {
return skip;
}
/**
* Sets how many cells in the grid that should be skipped <b>before</b> the component that this constraint belongs to.
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param cells How many cells in the grid that should be skipped <b>before</b> the component that this constraint belongs to
*/
public void setSkip(final int cells) {
this.skip = cells;
}
/**
* Returns the number of cells the cell that this constraint's component will span in the indicated dimension. <code>1</code>
* is default and
* means that it only spans the current cell. <code>LayoutUtil.INF</code> is used to indicate a span to the end of the
* column/row.
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public int getSpanX() {
return spanX;
}
/**
* Sets the number of cells the cell that this constraint's component will span in the indicated dimension. <code>1</code> is
* default and
* means that it only spans the current cell. <code>LayoutUtil.INF</code> is used to indicate a span to the end of the
* column/row.
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param cells The number of cells to span (i.e. merge).
*/
public void setSpanX(final int cells) {
this.spanX = cells;
}
/**
* Returns the number of cells the cell that this constraint's component will span in the indicated dimension. <code>1</code>
* is default and
* means that it only spans the current cell. <code>LayoutUtil.INF</code> is used to indicate a span to the end of the
* column/row.
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public int getSpanY() {
return spanY;
}
/**
* Sets the number of cells the cell that this constraint's component will span in the indicated dimension. <code>1</code> is
* default and
* means that it only spans the current cell. <code>LayoutUtil.INF</code> is used to indicate a span to the end of the
* column/row.
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param cells The number of cells to span (i.e. merge).
*/
public void setSpanY(final int cells) {
this.spanY = cells;
}
/**
* "pushx" indicates that the column that this component is in (this first if the component spans) should default to growing.
* If any other column has been set to grow this push value on the component does nothing as the column's explicit grow weight
* will take precedence. Push is normally used when the grid has not been defined in the layout.
* <p>
* If multiple components in a column has push weights set the largest one will be used for the column.
*
* @return The current push value. Default is <code>null</code>.
*/
public Float getPushX() {
return pushX;
}
/**
* "pushx" indicates that the column that this component is in (this first if the component spans) should default to growing.
* If any other column has been set to grow this push value on the component does nothing as the column's explicit grow weight
* will take precedence. Push is normally used when the grid has not been defined in the layout.
* <p>
* If multiple components in a column has push weights set the largest one will be used for the column.
*
* @param weight The new push value. Default is <code>null</code>.
*/
public void setPushX(final Float weight) {
this.pushX = weight;
}
/**
* "pushx" indicates that the row that this component is in (this first if the component spans) should default to growing.
* If any other row has been set to grow this push value on the component does nothing as the row's explicit grow weight
* will take precedence. Push is normally used when the grid has not been defined in the layout.
* <p>
* If multiple components in a row has push weights set the largest one will be used for the row.
*
* @return The current push value. Default is <code>null</code>.
*/
public Float getPushY() {
return pushY;
}
/**
* "pushx" indicates that the row that this component is in (this first if the component spans) should default to growing.
* If any other row has been set to grow this push value on the component does nothing as the row's explicit grow weight
* will take precedence. Push is normally used when the grid has not been defined in the layout.
* <p>
* If multiple components in a row has push weights set the largest one will be used for the row.
*
* @param weight The new push value. Default is <code>null</code>.
*/
public void setPushY(final Float weight) {
this.pushY = weight;
}
/**
* Returns in how many parts the current cell (that this constraint's component will be in) should be split in. If for
* instance
* it is split in two, the next component will also share the same cell. Note that the cell can also span a number of
* cells, which means that you can for instance span three cells and split that big cell for two components. Split can be
* set to a very high value to make all components in the same row/column share the same cell (e.g.
* <code>LayoutUtil.INF</code>).
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public int getSplit() {
return split;
}
/**
* Sets in how many parts the current cell (that this constraint's component will be in) should be split in. If for instance
* it is split in two, the next component will also share the same cell. Note that the cell can also span a number of
* cells, which means that you can for instance span three cells and split that big cell for two components. Split can be
* set to a very high value to make all components in the same row/column share the same cell (e.g.
* <code>LayoutUtil.INF</code>).
* <p>
* Note that only the first component will be checked for this property.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param parts The number of parts (i.e. component slots) the cell should be divided into.
*/
public void setSplit(final int parts) {
this.split = parts;
}
/**
* Tags the component with metadata. Currently only used to tag buttons with for instance "cancel" or "ok" to make them
* show up in the correct order depending on platform. See {@link PlatformDefaultsCommon#setButtonOrder(String)} for
* information.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value. May be <code>null</code>.
*/
public String getTag() {
return tag;
}
/**
* Optinal tag that gives more context to this constraint's component. It is for instance used to tag buttons in a
* button bar with the button type such as "ok", "help" or "cancel".
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param tag The new tag. May be <code>null</code>.
*/
public void setTag(final String tag) {
this.tag = tag;
}
/**
* Returns if the flow should wrap to the next line/column <b>after</b> the component that this constraint belongs to.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public boolean isWrap() {
return wrap != null;
}
/**
* Sets if the flow should wrap to the next line/column <b>after</b> the component that this constraint belongs to.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param b <code>true</code> means wrap after.
*/
public void setWrap(final boolean b) {
wrap = b ? (wrap == null ? DEF_GAP : wrap) : null;
}
/**
* Returns the wrap size if it is a custom size. If wrap was set to true with {@link #setWrap(boolean)} then this method will
* return <code>null</code> since that means that the gap size should be the default one as defined in the rows spec.
*
* @return The custom gap size. NOTE! Will return <code>null</code> for both no wrap <b>and</b> default wrap.
* @see #isWrap()
* @see #setWrap(boolean)
* @since 2.4.2
*/
public BoundSizeCommon getWrapGapSize() {
return wrap == DEF_GAP ? null : wrap;
}
/**
* Set the wrap size and turns wrap on if <code>!= null</code>.
*
* @param s The custom gap size. NOTE! <code>null</code> will not turn on or off wrap, it will only set the wrap gap size to
* "default".
* A non-null value will turn on wrap though.
* @see #isWrap()
* @see #setWrap(boolean)
* @since 2.4.2
*/
public void setWrapGapSize(final BoundSizeCommon s) {
wrap = s == null ? (wrap != null ? DEF_GAP : null) : s;
}
/**
* Returns if the flow should wrap to the next line/column <b>before</b> the component that this constraint belongs to.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @return The current value.
*/
public boolean isNewline() {
return newline != null;
}
/**
* Sets if the flow should wrap to the next line/column <b>before</b> the component that this constraint belongs to.
* <p>
* For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
*
* @param b <code>true</code> means wrap before.
*/
public void setNewline(final boolean b) {
newline = b ? (newline == null ? DEF_GAP : newline) : null;
}
/**
* Returns the newline size if it is a custom size. If newline was set to true with {@link #setNewline(boolean)} then this
* method will
* return <code>null</code> since that means that the gap size should be the default one as defined in the rows spec.
*
* @return The custom gap size. NOTE! Will return <code>null</code> for both no newline <b>and</b> default newline.
* @see #isNewline()
* @see #setNewline(boolean)
* @since 2.4.2
*/
public BoundSizeCommon getNewlineGapSize() {
return newline == DEF_GAP ? null : newline;
}
/**
* Set the newline size and turns newline on if <code>!= null</code>.
*
* @param s The custom gap size. NOTE! <code>null</code> will not turn on or off newline, it will only set the newline gap
* size to "default".
* A non-null value will turn on newline though.
* @see #isNewline()
* @see #setNewline(boolean)
* @since 2.4.2
*/
public void setNewlineGapSize(final BoundSizeCommon s) {
newline = s == null ? (newline != null ? DEF_GAP : null) : s;
}
// ************************************************
// Persistence Delegate and Serializable combined.
// ************************************************
private Object readResolve() throws ObjectStreamException {
return MigLayoutToolkitImpl.getMigLayoutUtil().getSerializedObject(this);
}
@Override
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {
final LayoutUtilCommon layoutUtil = MigLayoutToolkitImpl.getMigLayoutUtil();
layoutUtil.setSerializedObject(this, layoutUtil.readAsXML(in));
}
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
if (getClass() == CCCommon.class) {
MigLayoutToolkitImpl.getMigLayoutUtil().writeAsXML(out, this);
}
}
}