/**
* ------------------------------------------------------ Lays out the container's parts and it's
* background shape.
*
* @overrides MiLayout.doLayout ------------------------------------------------------
*/
protected void doLayout() {
if (!autoLayoutEnabled) return;
MiBounds contents = MiBounds.newBounds();
MiBounds oldContents = MiBounds.newBounds();
MiBounds containerBounds = MiBounds.newBounds();
MiBounds tmp = MiBounds.newBounds();
MiSize size = MiSize.newSize();
// -------------------------------------------------------
// Iterate through all parts of this container... set their
// size to their preferredSize if this container does not
// have a layout which has already done so. Also collect
// the union of their bounds into 'contents'.
// -------------------------------------------------------
for (int i = 0; i < getNumberOfParts(); ++i) {
if (getPart(i).isVisible()) {
// -------------------------------------------------------
// If contents have not already been laid out...
// -------------------------------------------------------
if ((getLayout() == null) || (!getLayout().determinesPreferredAndMinimumSizes())) {
getPart(i).getPreferredSize(size);
getPart(i).setSize(size);
}
getPart(i).getBounds(tmp);
contents.union(tmp);
}
}
// -------------------------------------------------------
// Set 'oldContents' to this current bounds of all of this
// container's parts. This will be used later to see it
// we have changed the size of this container. 'contents'
// will be modified by this layout routine as per the layout
// constraints applied to this container.
// -------------------------------------------------------
oldContents.copy(contents);
// -------------------------------------------------------
// Get the inner bounds of this container into 'container'.
// -------------------------------------------------------
MiBounds container = getInnerBounds(containerBounds);
if (container.isReversed()) {
getPreferredSize(size);
replaceBounds(new MiBounds(size));
container = getInnerBounds(containerBounds);
}
// -------------------------------------------------------
// Set the bounds to the center of the inner bounds.
// -------------------------------------------------------
contents.setCenterX(container.getCenterX());
contents.setCenterY(container.getCenterY());
// -------------------------------------------------------
// Expand the bounds to the size of the inner bounds, if
// so specified by the elementSizing contraints.
// -------------------------------------------------------
if (getElementHSizing() == Mi_EXPAND_TO_FILL) contents.setWidth(container.getWidth());
else if (getElementVSizing() == Mi_EXPAND_TO_FILL) contents.setHeight(container.getHeight());
// -------------------------------------------------------
// Translate the bounds in a horizontal direction if so
// specified by the elementHJustification contraint.
// -------------------------------------------------------
int elementHJustification = getElementHJustification();
if (elementHJustification == Mi_LEFT_JUSTIFIED) contents.translateXminTo(container.getXmin());
else if (elementHJustification == Mi_RIGHT_JUSTIFIED)
contents.translateXmaxTo(container.getXmax());
else if (elementHJustification == Mi_CENTER_JUSTIFIED)
contents.setCenterX(container.getCenterX());
else if (elementHJustification == Mi_JUSTIFIED) contents.setCenterX(container.getCenterX());
// -------------------------------------------------------
// Modify the bounds to stay within the inner bounds as
// held in the 'container' variable.
// -------------------------------------------------------
if (contents.getXmin() < container.getXmin()) contents.translateXminTo(container.getXmin());
if (contents.getXmax() > container.getXmax()) contents.translateXmaxTo(container.getXmax());
if (contents.getXmin() < container.getXmin()) contents.setXmin(container.getXmin());
// -------------------------------------------------------
// Translate the bounds in a vertical direction if so
// specified by the elementVJustification contraint.
// -------------------------------------------------------
int elementVJustification = getElementVJustification();
if (elementVJustification == Mi_BOTTOM_JUSTIFIED) contents.translateYminTo(container.getYmin());
else if (elementVJustification == Mi_TOP_JUSTIFIED)
contents.translateYmaxTo(container.getYmax());
else if (elementVJustification == Mi_CENTER_JUSTIFIED)
contents.setCenterY(container.getCenterY());
else if (elementVJustification == Mi_JUSTIFIED) contents.setCenterY(container.getCenterY());
// -------------------------------------------------------
// Modify the bounds to stay within the inner bounds as
// held in the 'container' variable.
// -------------------------------------------------------
if (container.getYmin() > contents.getYmin()) contents.translateYminTo(container.getYmin());
if (container.getYmax() < contents.getYmax()) contents.translateYmaxTo(container.getYmax());
if (container.getYmin() > contents.getYmin()) contents.setYmin(container.getYmin());
// -------------------------------------------------------
// If we have changed the bounds in some way...
// -------------------------------------------------------
if (!oldContents.equals(contents)) {
// -------------------------------------------------------
// Calculate how much we have to translate the parts...
// -------------------------------------------------------
MiDistance tx = contents.getCenterX() - oldContents.getCenterX();
MiDistance ty = contents.getCenterY() - oldContents.getCenterY();
// -------------------------------------------------------
// If there are no expand-to-fill contraints...
// -------------------------------------------------------
if ((getElementHSizing() != Mi_EXPAND_TO_FILL)
&& (getElementVSizing() != Mi_EXPAND_TO_FILL)) {
// -------------------------------------------------------
// Just translate all of the parts and we are done...
// -------------------------------------------------------
for (int i = 0; i < getNumberOfParts(); ++i) {
getPart(i).translate(tx, ty);
}
} else {
// -------------------------------------------------------
// There is an expand-to-fill contraint, we need to scale
// the parts... calculate the scale factor for each dimension.
// -------------------------------------------------------
MiPoint center = contents.getCenter();
MiScale scale =
new MiScale(
contents.getWidth() / oldContents.getWidth(),
contents.getHeight() / oldContents.getHeight());
if (getElementHSizing() != Mi_EXPAND_TO_FILL) scale.x = 1;
if (getElementVSizing() != Mi_EXPAND_TO_FILL) scale.y = 1;
// -------------------------------------------------------
// Iterate through the parts, translating and scaling
// -------------------------------------------------------
for (int i = 0; i < getNumberOfParts(); ++i) {
getPart(i).translate(tx, ty);
getPart(i).scale(center, scale);
}
}
}
// -------------------------------------------------------
// Release all the bounds we allocated above
// -------------------------------------------------------
MiBounds.freeBounds(contents);
MiBounds.freeBounds(oldContents);
MiBounds.freeBounds(containerBounds);
MiBounds.freeBounds(tmp);
MiSize.freeSize(size);
}
/**
* ------------------------------------------------------ Realculates the outer bounds of this
* container.
*
* @param bounds the (returned) outer bounds
* ------------------------------------------------------
*/
protected void reCalcBounds(MiBounds bounds) {
getBounds(bounds);
if (!autoLayoutEnabled) {
return;
}
MiBounds contents = MiBounds.newBounds();
MiMargins insetMargins = getInsetMargins();
MiMargins cellMargins = getCellMargins();
super.reCalcBounds(contents);
if (contents.isReversed()) {
contents.copy(bounds);
if (contents.isReversed()) {
contents.setBounds(0, 0, 0, 0);
contents.addMargins(insetMargins);
contents.addMargins(cellMargins);
contents.addMargins(getMargins(tmpMargins));
} else if ((contents.getWidth()
< insetMargins.getWidth()
+ getMargins(tmpMargins).getWidth()
+ cellMargins.getWidth())
|| (contents.getHeight()
< insetMargins.getHeight()
+ getMargins(tmpMargins).getHeight()
+ cellMargins.getHeight())) {
contents.setWidth(
insetMargins.getWidth() + getMargins(tmpMargins).getWidth() + cellMargins.getWidth());
contents.setHeight(
insetMargins.getHeight()
+ getMargins(tmpMargins).getHeight()
+ cellMargins.getHeight());
}
bounds.copy(contents);
} else {
// SUPER CLASS DOES THIS contents.addMargins(insetMargins);
contents.addMargins(cellMargins);
// SUPER CLASS DOES THIS contents.addMargins(getMargins(tmpMargins));
}
if ((autoLayoutRule == MAKE_CONTAINER_SAME_SIZE_AS_CONTENTS)) {
bounds.copy(contents);
} else if ((autoLayoutRule == MAKE_CONTAINER_SAME_SIZE_OR_BIGGER_THAN_CONTENTS)) {
if (!contents.isContainedIn(bounds)) bounds.copy(contents);
} else if ((autoLayoutRule
== MAKE_CONTAINER_SAME_SIZE_AS_CONTENTS_OR_OVERRIDDEN_PREFERRED_SIZE)) {
bounds.copy(contents);
if (hasOverriddenPreferredSize()) {
bounds.setSize(getPreferredSize(new MiSize()));
}
}
if (hasFixedWidthOrHeight) {
getBounds(contents);
if (hasFixedWidth()) {
bounds.xmin = contents.xmin;
bounds.xmax = contents.xmax;
}
if (hasFixedHeight()) {
bounds.ymin = contents.ymin;
bounds.ymax = contents.ymax;
}
}
MiBounds.freeBounds(contents);
}
protected void layoutParts(int h_sizing, int v_sizing, int h_justification, int v_justification) {
if (graphics != null) graphics.getPreferredSize(tmpSize);
else if (strValue != null) attributes.getFont().getSize(strValue, tmpSize);
else tmpSize.zeroOut();
MiBounds cellBounds = MiBounds.newBounds();
cellBounds.setSize(tmpSize);
MiBounds theInnerBounds = tmpBounds;
theInnerBounds.copy(innerBounds);
if (margins != null) theInnerBounds.subtractMargins(margins);
cellBounds.setCenterX(theInnerBounds.getCenterX());
cellBounds.setCenterY(theInnerBounds.getCenterY());
switch (h_sizing) {
case Mi_EXPAND_TO_FILL:
cellBounds.setWidth(theInnerBounds.getWidth());
break;
case Mi_SAME_SIZE:
cellBounds.setWidth(theInnerBounds.getWidth());
break;
case Mi_NONE:
default:
break;
}
switch (v_sizing) {
case Mi_EXPAND_TO_FILL:
cellBounds.setHeight(theInnerBounds.getHeight());
break;
case Mi_SAME_SIZE:
cellBounds.setHeight(theInnerBounds.getHeight());
break;
case Mi_NONE:
default:
break;
}
switch (h_justification) {
case Mi_JUSTIFIED:
case Mi_CENTER_JUSTIFIED:
case Mi_NONE:
cellBounds.setCenterX(theInnerBounds.getCenterX());
break;
case Mi_LEFT_JUSTIFIED:
cellBounds.translateXminTo(theInnerBounds.getXmin());
break;
case Mi_RIGHT_JUSTIFIED:
cellBounds.translateXmaxTo(theInnerBounds.getXmax());
break;
}
switch (v_justification) {
case Mi_JUSTIFIED:
case Mi_CENTER_JUSTIFIED:
case Mi_NONE:
cellBounds.setCenterY(theInnerBounds.getCenterY());
break;
case Mi_BOTTOM_JUSTIFIED:
cellBounds.translateYminTo(theInnerBounds.getYmin());
break;
case Mi_TOP_JUSTIFIED:
cellBounds.translateYmaxTo(theInnerBounds.getYmax());
break;
}
if (graphics != null) {
graphics.setBounds(cellBounds);
if (!graphics.hasValidLayout()) {
graphics.validateLayout();
}
} else {
innerBounds.copy(cellBounds);
}
MiBounds.freeBounds(cellBounds);
}
