X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=unused%2Fnet%2Fmiginfocom%2Flayout%2FLC.java;fp=unused%2Fnet%2Fmiginfocom%2Flayout%2FLC.java;h=b40fa75eb9c9840e66651e627f9b68cfa3b8ec54;hb=4f30214e8098748469c6a4269ac2ed6c5750e4b0;hp=0000000000000000000000000000000000000000;hpb=9dabc02511e3a334a5749a504f57f69d6c9017bd;p=jalview.git
diff --git a/unused/net/miginfocom/layout/LC.java b/unused/net/miginfocom/layout/LC.java
new file mode 100644
index 0000000..b40fa75
--- /dev/null
+++ b/unused/net/miginfocom/layout/LC.java
@@ -0,0 +1,1044 @@
+package net.miginfocom.layout;
+
+import java.io.*;
+/*
+ * License (BSD):
+ * ==============
+ *
+ * Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (miglayout (at) miginfocom (dot) com)
+ * 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
+ */
+
+/** Contains the constraints for an instance of the {@link LC} layout manager.
+ */
+public final class LC implements Externalizable
+{
+ // See the corresponding set/get method for documentation of the property!
+
+ private int wrapAfter = LayoutUtil.INF;
+
+ private Boolean leftToRight = null;
+
+ private UnitValue[] insets = null; // Never null elements but if unset array is null
+
+ private UnitValue alignX = null, alignY = null;
+
+ private BoundSize gridGapX = null, gridGapY = null;
+
+ private BoundSize width = BoundSize.NULL_SIZE, height = BoundSize.NULL_SIZE;
+
+ private BoundSize packW = BoundSize.NULL_SIZE, packH = BoundSize.NULL_SIZE;
+
+ private float pwAlign = 0.5f, phAlign = 1.0f;
+
+ private int debugMillis = 0;
+
+ private int hideMode = 0;
+
+ private boolean noCache = false;
+
+ private boolean flowX = true;
+
+ private boolean fillX = false, fillY = false;
+
+ private boolean topToBottom = true;
+
+ private boolean noGrid = false;
+
+ private boolean visualPadding = true;
+
+ /** Empty constructor.
+ */
+ public LC()
+ {
+ }
+
+ // ************************************************************************
+ // * JavaBean get/set methods.
+ // ************************************************************************
+
+
+ /** If components have sizes or positions linked to the bounds of the parent in some way (as for instance the "%"
unit has) the cache
+ * must be turned off for the panel. If components does not get the correct or expected size or position try to set this property to true
.
+ * @return true
means no cache and slightly slower layout.
+ */
+ public boolean isNoCache()
+ {
+ return noCache;
+ }
+
+ /** If components have sizes or positions linked to the bounds of the parent in some way (as for instance the "%"
unit has) the cache
+ * must be turned off for the panel. If components does not get the correct or expected size or position try to set this property to true
.
+ * @param b true
means no cache and slightly slower layout.
+ */
+ public void setNoCache(boolean b)
+ {
+ this.noCache = b;
+ }
+
+ /** If the laid out components' bounds in total is less than the final size of the container these align values will be used to align the components
+ * in the parent. null
is default and that means top/left alignment. The relative distances between the components will not be affected
+ * by this property.
+ * @return The current alignment.
+ */
+ public final UnitValue getAlignX()
+ {
+ return alignX;
+ }
+
+ /** If the laid out components' bounds in total is less than the final size of the container these align values will be used to align the components
+ * in the parent. null
is default and that means top/left alignment. The relative distances between the components will not be affected
+ * by this property.
+ * @param uv The new alignment. Use {@link ConstraintParser#parseAlignKeywords(String, boolean)} to create the {@link UnitValue}. May be null
.
+ */
+ public final void setAlignX(UnitValue uv)
+ {
+ this.alignX = uv;
+ }
+
+ /** If the laid out components' bounds in total is less than the final size of the container these align values will be used to align the components
+ * in the parent. null
is default and that means top/left alignment. The relative distances between the components will not be affected
+ * by this property.
+ * @return The current alignment.
+ */
+ public final UnitValue getAlignY()
+ {
+ return alignY;
+ }
+
+ /** If the laid out components' bounds in total is less than the final size of the container these align values will be used to align the components
+ * in the parent. null
is default and that means top/left alignment. The relative distances between the components will not be affected
+ * by this property.
+ * @param uv The new alignment. Use {@link ConstraintParser#parseAlignKeywords(String, boolean)} to create the {@link UnitValue}. May be null
.
+ */
+ public final void setAlignY(UnitValue uv)
+ {
+ this.alignY = uv;
+ }
+
+ /** If > 0
the debug decorations will be repainted every millis
. No debug information if <= 0
(default).
+ * @return The current debug repaint interval.
+ */
+ public final int getDebugMillis()
+ {
+ return debugMillis;
+ }
+
+ /** If > 0
the debug decorations will be repainted every millis
. No debug information if <= 0
(default).
+ * @param millis The new debug repaint interval.
+ */
+ public final void setDebugMillis(int millis)
+ {
+ this.debugMillis = millis;
+ }
+
+ /** If the layout should always claim the whole bounds of the laid out container even if the preferred size is smaller.
+ * @return true
means fill. false
is default.
+ */
+ public final boolean isFillX()
+ {
+ return fillX;
+ }
+
+ /** If the layout should always claim the whole bounds of the laid out container even if the preferred size is smaller.
+ * @param b true
means fill. false
is default.
+ */
+ public final void setFillX(boolean b)
+ {
+ this.fillX = b;
+ }
+
+ /** If the layout should always claim the whole bounds of the laid out container even if the preferred size is smaller.
+ * @return true
means fill. false
is default.
+ */
+ public final boolean isFillY()
+ {
+ return fillY;
+ }
+
+ /** If the layout should always claim the whole bounds of the laid out container even if the preferred size is smaller.
+ * @param b true
means fill. false
is default.
+ */
+ public final void setFillY(boolean b)
+ {
+ this.fillY = b;
+ }
+
+ /** The default flow direction. Normally (which is true
) this is horizontal and that means that the "next" component
+ * will be put in the cell to the right (or to the left if left-to-right is false).
+ * @return true
is the default flow horizontally.
+ * @see #setLeftToRight(Boolean)
+ */
+ public final boolean isFlowX()
+ {
+ return flowX;
+ }
+
+ /** The default flow direction. Normally (which is true
) this is horizontal and that means that the "next" component
+ * will be put in the cell to the right (or to the left if left-to-right is false).
+ * @param b true
is the default flow horizontally.
+ * @see #setLeftToRight(Boolean)
+ */
+ public final void setFlowX(boolean b)
+ {
+ this.flowX = b;
+ }
+
+ /** If non-null
(null
is default) these value will be used as the default gaps between the columns in the grid.
+ * @return The default grid gap between columns in the grid. null
if the platform default is used.
+ */
+ public final BoundSize getGridGapX()
+ {
+ return gridGapX;
+ }
+
+ /** If non-null
(null
is default) these value will be used as the default gaps between the columns in the grid.
+ * @param x The default grid gap between columns in the grid. If null
the platform default is used.
+ */
+ public final void setGridGapX(BoundSize x)
+ {
+ this.gridGapX = x;
+ }
+
+ /** If non-null
(null
is default) these value will be used as the default gaps between the rows in the grid.
+ * @return The default grid gap between rows in the grid. null
if the platform default is used.
+ */
+ public final BoundSize getGridGapY()
+ {
+ return gridGapY;
+ }
+
+ /** If non-null
(null
is default) these value will be used as the default gaps between the rows in the grid.
+ * @param y The default grid gap between rows in the grid. If null
the platform default is used.
+ */
+ public final void setGridGapY(BoundSize y)
+ {
+ this.gridGapY = y;
+ }
+
+ /** How a component that is hidden (not visible) should be treated by default.
+ * @return The mode:
+ * 0 == Normal. Bounds will be calculated as if the component was visible.
+ * 1 == If hidden the size will be 0, 0 but the gaps remain.
+ * 2 == If hidden the size will be 0, 0 and gaps set to zero.
+ * 3 == If hidden the component will be disregarded completely and not take up a cell in the grid..
+ */
+ public final int getHideMode()
+ {
+ return hideMode;
+ }
+
+ /** How a component that is hidden (not visible) should be treated.
+ * @param mode The mode:
+ * 0 == Normal. Bounds will be calculated as if the component was visible.
+ * 1 == If hidden the size will be 0, 0 but the gaps remain.
+ * 2 == If hidden the size will be 0, 0 and gaps set to zero.
+ * 3 == If hidden the component will be disregarded completely and not take up a cell in the grid..
+ */
+ public final void setHideMode(int mode)
+ {
+ if (mode < 0 || mode > 3)
+ throw new IllegalArgumentException("Wrong hideMode: " + mode);
+
+ this.hideMode = mode;
+ }
+
+ /** The insets for the layed out panel. The insets will be an empty space around the components in the panel. null
values
+ * means that the default panel insets for the platform is used. See {@link PlatformDefaults#setDialogInsets(net.miginfocom.layout.UnitValue, net.miginfocom.layout.UnitValue, net.miginfocom.layout.UnitValue, net.miginfocom.layout.UnitValue)}.
+ * @return The insets. Of length 4 (top, left, bottom, right) or null
. The elements (1 to 4) may be null
. The array is a copy and can be used freely.
+ * @see net.miginfocom.layout.ConstraintParser#parseInsets(String, boolean)
+ */
+ public final UnitValue[] getInsets()
+ {
+ return insets != null ? new UnitValue[] {insets[0], insets[1], insets[2], insets[3]} : null;
+ }
+
+ /** The insets for the layed out panel. The insets will be an empty space around the components in the panel. null
values
+ * means that the default panel insets for the platform is used. See {@link PlatformDefaults#setDialogInsets(net.miginfocom.layout.UnitValue, net.miginfocom.layout.UnitValue, net.miginfocom.layout.UnitValue, net.miginfocom.layout.UnitValue)}.
+ * @param ins The new insets. Must be of length 4 (top, left, bottom, right) or null
. The elements (1 to 4) may be null
to use
+ * the platform default for that side. The array is copied for storage.
+ * @see net.miginfocom.layout.ConstraintParser#parseInsets(String, boolean)
+ */
+ public final void setInsets(UnitValue[] ins)
+ {
+ this.insets = ins != null ? new UnitValue[] {ins[0], ins[1], ins[2], ins[3]} : null;
+ }
+
+ /** If the layout should be forced to be left-to-right or right-to-left. A value of null
is default and
+ * means that this will be picked up from the {@link java.util.Locale} that the container being layed out is reporting.
+ * @return Boolean.TRUE
if force left-to-right. Boolean.FALSE
if force tight-to-left. null
+ * for the default "let the current Locale decide".
+ */
+ public final Boolean getLeftToRight()
+ {
+ return leftToRight;
+ }
+
+ /** If the layout should be forced to be left-to-right or right-to-left. A value of null
is default and
+ * means that this will be picked up from the {@link java.util.Locale} that the container being layed out is reporting.
+ * @param b Boolean.TRUE
to force left-to-right. Boolean.FALSE
to force tight-to-left. null
+ * for the default "let the current Locale decide".
+ */
+ public final void setLeftToRight(Boolean b)
+ {
+ this.leftToRight = b;
+ }
+
+ /** If the whole layout should be non grid based. It is the same as setting the "nogrid" property on every row/column in the grid.
+ * @return true
means not grid based. false
is default.
+ */
+ public final boolean isNoGrid()
+ {
+ return noGrid;
+ }
+
+ /** If the whole layout should be non grid based. It is the same as setting the "nogrid" property on every row/column in the grid.
+ * @param b true
means no grid. false
is default.
+ */
+ public final void setNoGrid(boolean b)
+ {
+ this.noGrid = b;
+ }
+
+ /** If the layout should go from the default top-to-bottom in the grid instead of the optional bottom-to-top.
+ * @return true
for the default top-to-bottom.
+ */
+ public final boolean isTopToBottom()
+ {
+ return topToBottom;
+ }
+
+ /** If the layout should go from the default top-to-bottom in the grid instead of the optional bottom-to-top.
+ * @param b true
for the default top-to-bottom.
+ */
+ public final void setTopToBottom(boolean b)
+ {
+ this.topToBottom = b;
+ }
+
+ /** If visual padding should be automatically used and compensated for by this layout instance.
+ * @return true
if visual padding.
+ */
+ public final boolean isVisualPadding()
+ {
+ return visualPadding;
+ }
+
+ /** If visual padding should be automatically used and compensated for by this layout instance.
+ * @param b true
turns on visual padding.
+ */
+ public final void setVisualPadding(boolean b)
+ {
+ this.visualPadding = b;
+ }
+
+ /** Returns after what cell the grid should always auto wrap.
+ * @return After what cell the grid should always auto wrap. If 0
the number of columns/rows in the
+ * {@link net.miginfocom.layout.AC} is used. LayoutUtil.INF
is used for no auto wrap.
+ */
+ public final int getWrapAfter()
+ {
+ return wrapAfter;
+ }
+
+ /** Sets after what cell the grid should always auto wrap.
+ * @param count After what cell the grid should always auto wrap. If 0
the number of columns/rows in the
+ * {@link net.miginfocom.layout.AC} is used. LayoutUtil.INF
is used for no auto wrap.
+ */
+ public final void setWrapAfter(int count)
+ {
+ this.wrapAfter = count;
+ }
+
+ /** Returns the "pack width" for the window that this container is located in. When the size of this container changes
+ * the size of the window will be corrected to be within this BoundsSize. It can be used to set the minimum and/or maximum size of the window
+ * as well as the size window should optimally get. This optimal size is normally its "preferred" size which is why "preferred"
+ * is the normal value to set here.
+ *
+ * ":push" can be appended to the bound size to only push the size bigger and never shrink it if the preferred size gets smaller. + *
+ * E.g. "pref", "100:pref", "pref:700", "300::700", "pref:push"
+ * @return The current value. Never null
. Check if not set with .isUnset()
.
+ * @since 3.5
+ */
+ public final BoundSize getPackWidth()
+ {
+ return packW;
+ }
+
+ /** Sets the "pack width" for the window that this container is located in. When the size of this container changes
+ * the size of the window will be corrected to be within this BoundsSize. It can be used to set the minimum and/or maximum size of the window
+ * as well as the size window should optimally get. This optimal size is normally its "preferred" size which is why "preferred"
+ * is the normal value to set here.
+ *
+ * ":push" can be appended to the bound size to only push the size bigger and never shrink it if the preferred size gets smaller. + *
+ * E.g. "pref", "100:pref", "pref:700", "300::700", "pref:push"
+ * @param size The new pack size. If null
it will be corrected to an "unset" BoundSize.
+ * @since 3.5
+ */
+ public final void setPackWidth(BoundSize size)
+ {
+ packW = size != null ? size : BoundSize.NULL_SIZE;
+ }
+
+ /** Returns the "pack height" for the window that this container is located in. When the size of this container changes
+ * the size of the window will be corrected to be within this BoundsSize. It can be used to set the minimum and/or maximum size of the window
+ * as well as the size window should optimally get. This optimal size is normally its "preferred" size which is why "preferred"
+ * is the normal value to set here.
+ *
+ * ":push" can be appended to the bound size to only push the size bigger and never shrink it if the preferred size gets smaller. + *
+ * E.g. "pref", "100:pref", "pref:700", "300::700", "pref:push"
+ * @return The current value. Never null
. Check if not set with .isUnset()
.
+ * @since 3.5
+ */
+ public final BoundSize getPackHeight()
+ {
+ return packH;
+ }
+
+ /** Sets the "pack height" for the window that this container is located in. When the size of this container changes
+ * the size of the window will be corrected to be within this BoundsSize. It can be used to set the minimum and/or maximum size of the window
+ * as well as the size window should optimally get. This optimal size is normally its "preferred" size which is why "preferred"
+ * is the normal value to set here.
+ *
+ * ":push" can be appended to the bound size to only push the size bigger and never shrink it if the preferred size gets smaller. + *
+ * E.g. "pref", "100:pref", "pref:700", "300::700", "pref:push"
+ * @param size The new pack size. If null
it will be corrected to an "unset" BoundSize.
+ * @since 3.5
+ */
+ public final void setPackHeight(BoundSize size)
+ {
+ packH = size != null ? size : BoundSize.NULL_SIZE;
+ }
+
+
+ /** If there is a resize of the window due to packing (see {@link #setPackHeight(BoundSize)} this value, which is between 0f and 1f,
+ * decides where the extra/superfluous size is placed. 0f means that the window will resize so that the upper part moves up and the
+ * lower side stays in the same place. 0.5f will expand/reduce the window equally upwards and downwards. 1f will do the opposite of 0f
+ * of course.
+ * @return The pack alignment. Always between 0f and 1f, inclusive.
+ * @since 3.5
+ */
+ public final float getPackHeightAlign()
+ {
+ return phAlign;
+ }
+
+ /** If there is a resize of the window due to packing (see {@link #setPackHeight(BoundSize)} this value, which is between 0f and 1f,
+ * decides where the extra/superfluous size is placed. 0f means that the window will resize so that the upper part moves up and the
+ * lower side stays in the same place. 0.5f will expand/reduce the window equally upwards and downwards. 1f will do the opposite of 0f
+ * of course.
+ * @param align The pack alignment. Always between 0f and 1f, inclusive. Values outside this will be truncated.
+ * @since 3.5
+ */
+ public final void setPackHeightAlign(float align)
+ {
+ phAlign = Math.max(0f, Math.min(1f, align));
+ }
+
+ /** If there is a resize of the window due to packing (see {@link #setPackHeight(BoundSize)} this value, which is between 0f and 1f,
+ * decides where the extra/superfluous size is placed. 0f means that the window will resize so that the left part moves left and the
+ * right side stays in the same place. 0.5f will expand/reduce the window equally to the right and lefts. 1f will do the opposite of 0f
+ * of course.
+ * @return The pack alignment. Always between 0f and 1f, inclusive.
+ * @since 3.5
+ */
+ public final float getPackWidthAlign()
+ {
+ return pwAlign;
+ }
+
+ /** If there is a resize of the window due to packing (see {@link #setPackHeight(BoundSize)} this value, which is between 0f and 1f,
+ * decides where the extra/superfluous size is placed. 0f means that the window will resize so that the left part moves left and the
+ * right side stays in the same place. 0.5f will expand/reduce the window equally to the right and lefts. 1f will do the opposite of 0f
+ * of course.
+ * @param align The pack alignment. Always between 0f and 1f, inclusive. Values outside this will be truncated.
+ * @since 3.5
+ */
+ public final void setPackWidthAlign(float align)
+ {
+ pwAlign = Math.max(0f, Math.min(1f, align));
+ }
+
+ /** Returns the minimum/preferred/maximum size for the container that this layout constraint is set for. Any of these
+ * sizes that is not null
will be returned directly instead of determining the corresponding size through
+ * asking the components in this container.
+ * @return The width for the container that this layout constraint is set for. Not null
but
+ * all sizes can be null
.
+ * @since 3.5
+ */
+ public final BoundSize getWidth()
+ {
+ return width;
+ }
+
+ /** Sets the minimum/preferred/maximum size for the container that this layout constraint is set for. Any of these
+ * sizes that is not null
will be returned directly instead of determining the corresponding size through
+ * asking the components in this container.
+ * @param size The width for the container that this layout constraint is set for. null
is translated to
+ * a bound size containing only null sizes.
+ * @since 3.5
+ */
+ public final void setWidth(BoundSize size)
+ {
+ this.width = size != null ? size : BoundSize.NULL_SIZE;
+ }
+
+ /** Returns the minimum/preferred/maximum size for the container that this layout constraint is set for. Any of these
+ * sizes that is not null
will be returned directly instead of determining the corresponding size through
+ * asking the components in this container.
+ * @return The height for the container that this layout constraint is set for. Not null
but
+ * all sizes can be null
.
+ * @since 3.5
+ */
+ public final BoundSize getHeight()
+ {
+ return height;
+ }
+
+ /** Sets the minimum/preferred/maximum size for the container that this layout constraint is set for. Any of these
+ * sizes that is not null
will be returned directly instead of determining the corresponding size through
+ * asking the components in this container.
+ * @param size The height for the container that this layout constraint is set for. null
is translated to
+ * a bound size containing only null sizes.
+ * @since 3.5
+ */
+ public final void setHeight(BoundSize size)
+ {
+ this.height = size != null ? size : BoundSize.NULL_SIZE;
+ }
+
+ // ************************************************************************
+ // * Builder methods.
+ // ************************************************************************
+
+ /** Short for, and thus same as, .pack("pref", "pref")
.
+ *
+ * Same functionality as {@link #setPackHeight(BoundSize)} and {@link #setPackWidth(net.miginfocom.layout.BoundSize)}
+ * only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @since 3.5
+ */
+ public final LC pack()
+ {
+ return pack("pref", "pref");
+ }
+
+ /** Sets the pack width and height.
+ *
+ * Same functionality as {@link #setPackHeight(BoundSize)} and {@link #setPackWidth(net.miginfocom.layout.BoundSize)}
+ * only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param width The pack width. May be null
.
+ * @param height The pack height. May be null
.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @since 3.5
+ */
+ public final LC pack(String width, String height)
+ {
+ setPackWidth(width != null ? ConstraintParser.parseBoundSize(width, false, true) : BoundSize.NULL_SIZE);
+ setPackHeight(height != null ? ConstraintParser.parseBoundSize(height, false, false) : BoundSize.NULL_SIZE);
+ return this;
+ }
+
+ /** Sets the pack width and height alignment.
+ *
+ * Same functionality as {@link #setPackHeightAlign(float)} and {@link #setPackWidthAlign(float)}
+ * only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param alignX The pack width alignment. 0.5f is default.
+ * @param alignY The pack height alignment. 0.5f is default.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @since 3.5
+ */
+ public final LC packAlign(float alignX, float alignY)
+ {
+ setPackWidthAlign(alignX);
+ setPackHeightAlign(alignY);
+ return this;
+ }
+
+ /** Sets a wrap after the number of columns/rows that is defined in the {@link net.miginfocom.layout.AC}.
+ *
+ * Same functionality as calling {@link #setWrapAfter(int)} with 0
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC wrap()
+ {
+ setWrapAfter(0);
+ return this;
+ }
+
+ /** Same functionality as {@link #setWrapAfter(int)} only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param count After what cell the grid should always auto wrap. If 0
the number of columns/rows in the
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC wrapAfter(int count)
+ {
+ setWrapAfter(count);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setNoCache(boolean)} with true
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC noCache()
+ {
+ setNoCache(true);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setFlowX(boolean)} with false
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC flowY()
+ {
+ setFlowX(false);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setFlowX(boolean)} with true
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC flowX()
+ {
+ setFlowX(true);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setFillX(boolean)} with true
and {@link #setFillY(boolean)} with true
conmbined.T his method returns
+ * this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC fill()
+ {
+ setFillX(true);
+ setFillY(true);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setFillX(boolean)} with true
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC fillX()
+ {
+ setFillX(true);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setFillY(boolean)} with true
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC fillY()
+ {
+ setFillY(true);
+ return this;
+ }
+
+ /** Same functionality as {@link #setLeftToRight(Boolean)} only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param b true
for forcing left-to-right. false
for forcing right-to-left.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC leftToRight(boolean b)
+ {
+ setLeftToRight(b ? Boolean.TRUE : Boolean.FALSE);
+ return this;
+ }
+
+ /** Same functionality as setLeftToRight(false) only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @since 3.7.2
+ */
+ public final LC rightToLeft()
+ {
+ setLeftToRight(Boolean.FALSE);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setTopToBottom(boolean)} with false
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC bottomToTop()
+ {
+ setTopToBottom(false);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setTopToBottom(boolean)} with true
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @since 3.7.2
+ */
+ public final LC topToBottom()
+ {
+ setTopToBottom(true);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setNoGrid(boolean)} with true
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC noGrid()
+ {
+ setNoGrid(true);
+ return this;
+ }
+
+ /** Same functionality as calling {@link #setVisualPadding(boolean)} with false
only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC noVisualPadding()
+ {
+ setVisualPadding(false);
+ return this;
+ }
+
+ /** Sets the same inset (expressed as a UnitValue
, e.g. "10px" or "20mm") all around.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param allSides The unit value to set for all sides. May be null
which means that the default panel insets
+ * for the platform is used.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setInsets(UnitValue[])
+ */
+ public final LC insetsAll(String allSides)
+ {
+ UnitValue insH = ConstraintParser.parseUnitValue(allSides, true);
+ UnitValue insV = ConstraintParser.parseUnitValue(allSides, false);
+ insets = new UnitValue[] {insV, insH, insV, insH}; // No setter to avoid copy again
+ return this;
+ }
+
+ /** Same functionality as setInsets(ConstraintParser.parseInsets(s, true))
. This method returns this
+ * for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param s 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 this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setInsets(UnitValue[])
+ */
+ public final LC insets(String s)
+ {
+ insets = ConstraintParser.parseInsets(s, true);
+ return this;
+ }
+
+ /** Sets the different insets (expressed as a UnitValue
s, e.g. "10px" or "20mm") for the corresponding sides.
+ *
+ * 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 inset. E.g. "10px" or "10mm" or "related". May be null
in which case the default inset for this
+ * side for the platform will be used.
+ * @param left The left inset. E.g. "10px" or "10mm" or "related". May be null
in which case the default inset for this
+ * side for the platform will be used.
+ * @param bottom The bottom inset. E.g. "10px" or "10mm" or "related". May be null
in which case the default inset for this
+ * side for the platform will be used.
+ * @param right The right inset. E.g. "10px" or "10mm" or "related". May be null
in which case the default inset for this
+ * side for the platform will be used.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setInsets(UnitValue[])
+ */
+ public final LC insets(String top, String left, String bottom, String right)
+ {
+ insets = new UnitValue[] { // No setter to avoid copy again
+ ConstraintParser.parseUnitValue(top, false),
+ ConstraintParser.parseUnitValue(left, true),
+ ConstraintParser.parseUnitValue(bottom, false),
+ ConstraintParser.parseUnitValue(right, true)};
+ return this;
+ }
+
+ /** Same functionality as setAlignX(ConstraintParser.parseUnitValueOrAlign(unitValue, true))
only this method returns this
+ * for chaining multiple calls.
+ *
+ * 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 this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setAlignX(UnitValue)
+ */
+ public final LC alignX(String align)
+ {
+ setAlignX(ConstraintParser.parseUnitValueOrAlign(align, true, null));
+ return this;
+ }
+
+ /** Same functionality as setAlignY(ConstraintParser.parseUnitValueOrAlign(align, false))
only this method returns this
for chaining multiple calls.
+ *
+ * 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 this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setAlignY(UnitValue)
+ */
+ public final LC alignY(String align)
+ {
+ setAlignY(ConstraintParser.parseUnitValueOrAlign(align, false, null));
+ return this;
+ }
+
+ /** Sets both the alignX and alignY as the same time.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param ax The align keyword or for instance "100px". E.g "left", "right", "leading" or "trailing".
+ * @param ay The align keyword or for instance "100px". E.g "top" or "bottom".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #alignX(String)
+ * @see #alignY(String)
+ */
+ public final LC align(String ax, String ay)
+ {
+ if (ax != null)
+ alignX(ax);
+
+ if (ay != null)
+ alignY(ay);
+
+ return this;
+ }
+
+ /** Same functionality as setGridGapX(ConstraintParser.parseBoundSize(boundsSize, true, true))
only this method
+ * returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param boundsSize The BoundSize
of the gap. This is a minimum and/or preferred and/or maximum size. E.g.
+ * "50:100:200"
or "100px"
.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setGridGapX(BoundSize)
+ */
+ public final LC gridGapX(String boundsSize)
+ {
+ setGridGapX(ConstraintParser.parseBoundSize(boundsSize, true, true));
+ return this;
+ }
+
+ /** Same functionality as setGridGapY(ConstraintParser.parseBoundSize(boundsSize, true, false))
only this method
+ * returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param boundsSize The BoundSize
of the gap. This is a minimum and/or preferred and/or maximum size. E.g.
+ * "50:100:200"
or "100px"
.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setGridGapY(BoundSize)
+ */
+ public final LC gridGapY(String boundsSize)
+ {
+ setGridGapY(ConstraintParser.parseBoundSize(boundsSize, true, false));
+ return this;
+ }
+
+ /** Sets both grid gaps at the same time. see {@link #gridGapX(String)} and {@link #gridGapY(String)}.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param gapx The BoundSize
of the gap. This is a minimum and/or preferred and/or maximum size. E.g.
+ * "50:100:200"
or "100px"
.
+ * @param gapy The BoundSize
of the gap. This is a minimum and/or preferred and/or maximum size. E.g.
+ * "50:100:200"
or "100px"
.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #gridGapX(String)
+ * @see #gridGapY(String)
+ */
+ public final LC gridGap(String gapx, String gapy)
+ {
+ if (gapx != null)
+ gridGapX(gapx);
+
+ if (gapy != null)
+ gridGapY(gapy);
+
+ return this;
+ }
+
+ /** Calls {@link #debug(int)} with 300 as an argument.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setDebugMillis(int)
+ */
+ public final LC debug()
+ {
+ setDebugMillis(300);
+ return this;
+ }
+
+ /** Same functionality as {@link #setDebugMillis(int repaintMillis)} only this method returns this
for chaining multiple calls.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcomponents.com.
+ * @param repaintMillis The new debug repaint interval.
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setDebugMillis(int)
+ */
+ public final LC debug(int repaintMillis)
+ {
+ setDebugMillis(repaintMillis);
+ return this;
+ }
+
+ /** Same functionality as {@link #setHideMode(int mode)} only this method returns this
for chaining multiple calls.
+ *
+ * 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:
+ * 0 == Normal. Bounds will be calculated as if the component was visible.
+ * 1 == If hidden the size will be 0, 0 but the gaps remain.
+ * 2 == If hidden the size will be 0, 0 and gaps set to zero.
+ * 3 == If hidden the component will be disregarded completely and not take up a cell in the grid..
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ * @see #setHideMode(int)
+ */
+ public final LC hideMode(int mode)
+ {
+ setHideMode(mode);
+ return this;
+ }
+
+ /** The minimum width for the container. The value will override any value that is set on the container itself.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or Cheat Sheet at www.migcontainers.com.
+ * @param width The width expressed as a UnitValue
. E.g. "100px" or "200mm".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC minWidth(String width)
+ {
+ setWidth(LayoutUtil.derive(getWidth(), ConstraintParser.parseUnitValue(width, true), null, null));
+ return this;
+ }
+
+ /** The width for the container as a min and/or preferred and/or maximum width. The value will override any value that is set on
+ * the container itself.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or Cheat Sheet at www.migcontainers.com.
+ * @param width The width expressed as a BoundSize
. E.g. "50:100px:200mm" or "100px".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC width(String width)
+ {
+ setWidth(ConstraintParser.parseBoundSize(width, false, true));
+ return this;
+ }
+
+ /** The maximum width for the container. The value will override any value that is set on the container itself.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or Cheat Sheet at www.migcontainers.com.
+ * @param width The width expressed as a UnitValue
. E.g. "100px" or "200mm".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC maxWidth(String width)
+ {
+ setWidth(LayoutUtil.derive(getWidth(), null, null, ConstraintParser.parseUnitValue(width, true)));
+ return this;
+ }
+
+ /** The minimum height for the container. The value will override any value that is set on the container itself.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or Cheat Sheet at www.migcontainers.com.
+ * @param height The height expressed as a UnitValue
. E.g. "100px" or "200mm".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC minHeight(String height)
+ {
+ setHeight(LayoutUtil.derive(getHeight(), ConstraintParser.parseUnitValue(height, false), null, null));
+ return this;
+ }
+
+ /** The height for the container as a min and/or preferred and/or maximum height. The value will override any value that is set on
+ * the container itself.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcontainers.com.
+ * @param height The height expressed as a BoundSize
. E.g. "50:100px:200mm" or "100px".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC height(String height)
+ {
+ setHeight(ConstraintParser.parseBoundSize(height, false, false));
+ return this;
+ }
+
+ /** The maximum height for the container. The value will override any value that is set on the container itself.
+ *
+ * For a more thorough explanation of what this constraint does see the white paper or cheat Sheet at www.migcontainers.com.
+ * @param height The height expressed as a UnitValue
. E.g. "100px" or "200mm".
+ * @return this
so it is possible to chain calls. E.g. new LayoutConstraint().noGrid().gap().fill()
.
+ */
+ public final LC maxHeight(String height)
+ {
+ setHeight(LayoutUtil.derive(getHeight(), null, null, ConstraintParser.parseUnitValue(height, false)));
+ return this;
+ }
+
+ // ************************************************
+ // Persistence Delegate and Serializable combined.
+ // ************************************************
+
+ private Object readResolve() throws ObjectStreamException
+ {
+ return LayoutUtil.getSerializedObject(this);
+ }
+
+ @Override
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
+ {
+ LayoutUtil.setSerializedObject(this, LayoutUtil.readAsXML(in));
+ }
+
+ @Override
+ public void writeExternal(ObjectOutput out) throws IOException
+ {
+ if (getClass() == LC.class)
+ LayoutUtil.writeAsXML(out, this);
+ }
+}