|
@@ -0,0 +1,1045 @@
|
|
|
+/* ========================================================================
|
|
|
+ * JCommon : a free general purpose class library for the Java(tm) platform
|
|
|
+ * ========================================================================
|
|
|
+ *
|
|
|
+ * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
|
|
|
+ *
|
|
|
+ * Project Info: http://www.jfree.org/jcommon/index.html
|
|
|
+ *
|
|
|
+ * This library is free software; you can redistribute it and/or modify it
|
|
|
+ * under the terms of the GNU Lesser General Public License as published by
|
|
|
+ * the Free Software Foundation; either version 2.1 of the License, or
|
|
|
+ * (at your option) any later version.
|
|
|
+ *
|
|
|
+ * This library is distributed in the hope that it will be useful, but
|
|
|
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
|
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
|
+ * License for more details.
|
|
|
+ *
|
|
|
+ * You should have received a copy of the GNU Lesser General Public
|
|
|
+ * License along with this library; if not, write to the Free Software
|
|
|
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
|
+ * USA.
|
|
|
+ *
|
|
|
+ * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
|
|
|
+ * in the United States and other countries.]
|
|
|
+ *
|
|
|
+ * -----------------
|
|
|
+ * FormatLayout.java
|
|
|
+ * -----------------
|
|
|
+ * (C) Copyright 2000-2005, by Object Refinery Limited.
|
|
|
+ *
|
|
|
+ * Original Author: David Gilbert (for Object Refinery Limited);
|
|
|
+ * Contributor(s): -;
|
|
|
+ *
|
|
|
+ * $Id: FormatLayout.java,v 1.4 2005/10/18 13:16:50 mungady Exp $
|
|
|
+ *
|
|
|
+ * Changes (from 26-Oct-2001)
|
|
|
+ * --------------------------
|
|
|
+ * 26-Oct-2001 : Changed package to com.jrefinery.layout.* (DG);
|
|
|
+ * 26-Jun-2002 : Removed redundant code (DG);
|
|
|
+ * 10-Oct-2002 : Fixed errors reported by Checkstyle (DG);
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+package org.jfree.layout;
|
|
|
+
|
|
|
+import java.awt.Component;
|
|
|
+import java.awt.Container;
|
|
|
+import java.awt.Dimension;
|
|
|
+import java.awt.Insets;
|
|
|
+import java.awt.LayoutManager;
|
|
|
+import java.io.Serializable;
|
|
|
+
|
|
|
+/**
|
|
|
+ * A layout manager that spaces components over six columns in seven different
|
|
|
+ * formats.
|
|
|
+ *
|
|
|
+ * @author David Gilbert
|
|
|
+ */
|
|
|
+public class FormatLayout implements LayoutManager, Serializable {
|
|
|
+
|
|
|
+ /** For serialization. */
|
|
|
+ private static final long serialVersionUID = 2866692886323930722L;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 1. */
|
|
|
+ public static final int C = 1;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 2. */
|
|
|
+ public static final int LC = 2;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 3. */
|
|
|
+ public static final int LCB = 3;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 4. */
|
|
|
+ public static final int LCLC = 4;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 5. */
|
|
|
+ public static final int LCLCB = 5;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 6. */
|
|
|
+ public static final int LCBLC = 6;
|
|
|
+
|
|
|
+ /** A useful constant representing layout format 7. */
|
|
|
+ public static final int LCBLCB = 7;
|
|
|
+
|
|
|
+ /** The layout format for each row. */
|
|
|
+ private int[] rowFormats;
|
|
|
+
|
|
|
+ /** The gap between the rows. */
|
|
|
+ private int rowGap;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The gaps between the columns (gap[0] is the gap following column zero).
|
|
|
+ */
|
|
|
+ private int[] columnGaps;
|
|
|
+
|
|
|
+ /** Working array for recording the height of each row. */
|
|
|
+ private int[] rowHeights;
|
|
|
+
|
|
|
+ /** The total height of the layout. */
|
|
|
+ private int totalHeight;
|
|
|
+
|
|
|
+ /** Working array for recording the width of each column. */
|
|
|
+ private int[] columnWidths;
|
|
|
+
|
|
|
+ /** The total width of the layout. */
|
|
|
+ private int totalWidth;
|
|
|
+
|
|
|
+ /** Combined width of columns 1 and 2. */
|
|
|
+ private int columns1and2Width;
|
|
|
+
|
|
|
+ /** Combined width of columns 4 and 5. */
|
|
|
+ private int columns4and5Width;
|
|
|
+
|
|
|
+ /** Combined width of columns 1 to 4. */
|
|
|
+ private int columns1to4Width;
|
|
|
+
|
|
|
+ /** Combined width of columns 1 to 5. */
|
|
|
+ private int columns1to5Width;
|
|
|
+
|
|
|
+ /** Combined width of columns 0 to 5. */
|
|
|
+ private int columns0to5Width;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Constructs a new layout manager that can be used to create input forms.
|
|
|
+ * The layout manager works by arranging components in rows using six
|
|
|
+ * columns (some components will use more than one column).
|
|
|
+ * <P>
|
|
|
+ * Any component can be added, but I think of them in terms of Labels,
|
|
|
+ * Components, and Buttons.
|
|
|
+ * The formats available are: C, LC, LCB, LCLC, LCLCB, LCBLC or LCBLCB.
|
|
|
+ * <table summary="layout options" >
|
|
|
+ * <tr>
|
|
|
+ * <td>C</td>
|
|
|
+ * <td>1 component in this row (spread across all six columns).</td>
|
|
|
+ * </tr>
|
|
|
+ * <tr>
|
|
|
+ * <td>LC</td>
|
|
|
+ * <td>2 components, a label in the 1st column, and a component using the
|
|
|
+ * remaining 5 columns).</td>
|
|
|
+ * </tr>
|
|
|
+ * <tr>
|
|
|
+ * <td>LCB</td>
|
|
|
+ * <td>3 components, a label in the 1st column, a component spread across
|
|
|
+ * the next 4, and a button in the last column.</td>
|
|
|
+ * </tr>
|
|
|
+ * <tr>
|
|
|
+ * <td>LCLC</td>
|
|
|
+ * <td>4 components, a label in column 1, a component in 2-3, a label in
|
|
|
+ * 4 and a component in 5-6.</td>
|
|
|
+ * </tr>
|
|
|
+ * <tr>
|
|
|
+ * <td>LCLCB</td>
|
|
|
+ * <td>5 components, a label in column 1, a component in 2-3, a label
|
|
|
+ * in 4, a component in 5 and a button in 6.</td>
|
|
|
+ * </tr>
|
|
|
+ * <tr>
|
|
|
+ * <td>LCBLC</td>
|
|
|
+ * <td>5 components, a label in column 1, a component in 2, a button in 3,
|
|
|
+ * a label in 4, a component in 5-6.</td>
|
|
|
+ * </tr>
|
|
|
+ * <tr>
|
|
|
+ * <td>LCBLCB</td>
|
|
|
+ * <td>6 components, one in each column.</td>
|
|
|
+ * </tr>
|
|
|
+ * </table>
|
|
|
+ * <P>
|
|
|
+ * Columns 1 and 4 expand to accommodate the widest label, and 3 and 6 to
|
|
|
+ * accommodate the widest button.
|
|
|
+ * <P>
|
|
|
+ * Each row will contain the number of components indicated by the format.
|
|
|
+ * Be sure to specify enough row formats to cover all the components you
|
|
|
+ * add to the layout.
|
|
|
+ *
|
|
|
+ * @param rowCount the number of rows.
|
|
|
+ * @param rowFormats the row formats.
|
|
|
+ */
|
|
|
+ public FormatLayout(final int rowCount, final int[] rowFormats) {
|
|
|
+
|
|
|
+ this.rowFormats = rowFormats;
|
|
|
+ this.rowGap = 2;
|
|
|
+ this.columnGaps = new int[5];
|
|
|
+ this.columnGaps[0] = 10;
|
|
|
+ this.columnGaps[1] = 5;
|
|
|
+ this.columnGaps[2] = 5;
|
|
|
+ this.columnGaps[3] = 10;
|
|
|
+ this.columnGaps[4] = 5;
|
|
|
+
|
|
|
+ // working structures...
|
|
|
+ this.rowHeights = new int[rowCount];
|
|
|
+ this.columnWidths = new int[6];
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the preferred size of the component using this layout manager.
|
|
|
+ *
|
|
|
+ * @param parent the parent.
|
|
|
+ *
|
|
|
+ * @return the preferred size of the component.
|
|
|
+ */
|
|
|
+ public Dimension preferredLayoutSize(final Container parent) {
|
|
|
+
|
|
|
+ Component c0, c1, c2, c3, c4, c5;
|
|
|
+
|
|
|
+ synchronized (parent.getTreeLock()) {
|
|
|
+ final Insets insets = parent.getInsets();
|
|
|
+ int componentIndex = 0;
|
|
|
+ final int rowCount = this.rowHeights.length;
|
|
|
+ for (int i = 0; i < this.columnWidths.length; i++) {
|
|
|
+ this.columnWidths[i] = 0;
|
|
|
+ }
|
|
|
+ this.columns1and2Width = 0;
|
|
|
+ this.columns4and5Width = 0;
|
|
|
+ this.columns1to4Width = 0;
|
|
|
+ this.columns1to5Width = 0;
|
|
|
+ this.columns0to5Width = 0;
|
|
|
+
|
|
|
+ this.totalHeight = 0;
|
|
|
+ for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
|
|
|
+ final int format
|
|
|
+ = this.rowFormats[rowIndex % this.rowFormats.length];
|
|
|
+ switch (format) {
|
|
|
+ case FormatLayout.C:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ updateC(rowIndex, c0.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 1;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ updateLC(rowIndex, c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 2;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ updateLCB(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 3;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ updateLCLC(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 4;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ updateLCBLC(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize(),
|
|
|
+ c4.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ updateLCLCB(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize(),
|
|
|
+ c4.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ c5 = parent.getComponent(componentIndex + 5);
|
|
|
+ updateLCBLCB(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize(),
|
|
|
+ c4.getPreferredSize(),
|
|
|
+ c5.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 6;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ complete();
|
|
|
+ return new Dimension(this.totalWidth + insets.left + insets.right,
|
|
|
+ this.totalHeight + (rowCount - 1) * this.rowGap
|
|
|
+ + insets.top + insets.bottom);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the minimum size of the component using this layout manager.
|
|
|
+ *
|
|
|
+ * @param parent the parent.
|
|
|
+ *
|
|
|
+ * @return the minimum size of the component
|
|
|
+ */
|
|
|
+ public Dimension minimumLayoutSize(final Container parent) {
|
|
|
+
|
|
|
+ Component c0, c1, c2, c3, c4, c5;
|
|
|
+
|
|
|
+ synchronized (parent.getTreeLock()) {
|
|
|
+ final Insets insets = parent.getInsets();
|
|
|
+ int componentIndex = 0;
|
|
|
+ final int rowCount = this.rowHeights.length;
|
|
|
+ for (int i = 0; i < this.columnWidths.length; i++) {
|
|
|
+ this.columnWidths[i] = 0;
|
|
|
+ }
|
|
|
+ this.columns1and2Width = 0;
|
|
|
+ this.columns4and5Width = 0;
|
|
|
+ this.columns1to4Width = 0;
|
|
|
+ this.columns1to5Width = 0;
|
|
|
+ this.columns0to5Width = 0;
|
|
|
+ final int totalHeight = 0;
|
|
|
+ for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
|
|
|
+
|
|
|
+ final int format
|
|
|
+ = this.rowFormats[rowIndex % this.rowFormats.length];
|
|
|
+
|
|
|
+ switch (format) {
|
|
|
+ case FormatLayout.C:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ this.columns0to5Width = Math.max(
|
|
|
+ this.columns0to5Width, c0.getMinimumSize().width
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 1;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ updateLC(rowIndex,
|
|
|
+ c0.getMinimumSize(),
|
|
|
+ c1.getMinimumSize());
|
|
|
+ componentIndex = componentIndex + 2;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ updateLCB(rowIndex,
|
|
|
+ c0.getMinimumSize(),
|
|
|
+ c1.getMinimumSize(),
|
|
|
+ c2.getMinimumSize());
|
|
|
+ componentIndex = componentIndex + 3;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ updateLCLC(rowIndex,
|
|
|
+ c0.getMinimumSize(),
|
|
|
+ c1.getMinimumSize(),
|
|
|
+ c2.getMinimumSize(),
|
|
|
+ c3.getMinimumSize());
|
|
|
+ componentIndex = componentIndex + 3;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ updateLCBLC(rowIndex,
|
|
|
+ c0.getMinimumSize(),
|
|
|
+ c1.getMinimumSize(),
|
|
|
+ c2.getMinimumSize(),
|
|
|
+ c3.getMinimumSize(),
|
|
|
+ c4.getMinimumSize());
|
|
|
+ componentIndex = componentIndex + 4;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ updateLCLCB(rowIndex,
|
|
|
+ c0.getMinimumSize(),
|
|
|
+ c1.getMinimumSize(),
|
|
|
+ c2.getMinimumSize(),
|
|
|
+ c3.getMinimumSize(),
|
|
|
+ c4.getMinimumSize());
|
|
|
+ componentIndex = componentIndex + 4;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ c5 = parent.getComponent(componentIndex + 5);
|
|
|
+ updateLCBLCB(rowIndex,
|
|
|
+ c0.getMinimumSize(),
|
|
|
+ c1.getMinimumSize(),
|
|
|
+ c2.getMinimumSize(),
|
|
|
+ c3.getMinimumSize(),
|
|
|
+ c4.getMinimumSize(),
|
|
|
+ c5.getMinimumSize());
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ complete();
|
|
|
+ return new Dimension(this.totalWidth + insets.left + insets.right,
|
|
|
+ totalHeight + (rowCount - 1) * this.rowGap
|
|
|
+ + insets.top + insets.bottom);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Performs the layout of the container.
|
|
|
+ *
|
|
|
+ * @param parent the parent.
|
|
|
+ */
|
|
|
+ public void layoutContainer(final Container parent) {
|
|
|
+ Component c0, c1, c2, c3, c4, c5;
|
|
|
+
|
|
|
+ synchronized (parent.getTreeLock()) {
|
|
|
+ final Insets insets = parent.getInsets();
|
|
|
+ int componentIndex = 0;
|
|
|
+ final int rowCount = this.rowHeights.length;
|
|
|
+ for (int i = 0; i < this.columnWidths.length; i++) {
|
|
|
+ this.columnWidths[i] = 0;
|
|
|
+ }
|
|
|
+ this.columns1and2Width = 0;
|
|
|
+ this.columns4and5Width = 0;
|
|
|
+ this.columns1to4Width = 0;
|
|
|
+ this.columns1to5Width = 0;
|
|
|
+ this.columns0to5Width
|
|
|
+ = parent.getBounds().width - insets.left - insets.right;
|
|
|
+
|
|
|
+ this.totalHeight = 0;
|
|
|
+ for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
|
|
|
+ final int format
|
|
|
+ = this.rowFormats[rowIndex % this.rowFormats.length];
|
|
|
+ switch (format) {
|
|
|
+ case FormatLayout.C:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ updateC(rowIndex, c0.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 1;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ updateLC(rowIndex, c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 2;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ updateLCB(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 3;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ updateLCLC(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 4;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ updateLCBLC(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize(),
|
|
|
+ c4.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ updateLCLCB(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize(),
|
|
|
+ c4.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ c5 = parent.getComponent(componentIndex + 5);
|
|
|
+ updateLCBLCB(rowIndex,
|
|
|
+ c0.getPreferredSize(),
|
|
|
+ c1.getPreferredSize(),
|
|
|
+ c2.getPreferredSize(),
|
|
|
+ c3.getPreferredSize(),
|
|
|
+ c4.getPreferredSize(),
|
|
|
+ c5.getPreferredSize());
|
|
|
+ componentIndex = componentIndex + 6;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ complete();
|
|
|
+
|
|
|
+ componentIndex = 0;
|
|
|
+ int rowY = insets.top;
|
|
|
+ final int[] rowX = new int[6];
|
|
|
+ rowX[0] = insets.left;
|
|
|
+ rowX[1] = rowX[0] + this.columnWidths[0] + this.columnGaps[0];
|
|
|
+ rowX[2] = rowX[1] + this.columnWidths[1] + this.columnGaps[1];
|
|
|
+ rowX[3] = rowX[2] + this.columnWidths[2] + this.columnGaps[2];
|
|
|
+ rowX[4] = rowX[3] + this.columnWidths[3] + this.columnGaps[3];
|
|
|
+ rowX[5] = rowX[4] + this.columnWidths[4] + this.columnGaps[4];
|
|
|
+ final int w1to2 = this.columnWidths[1] + this.columnGaps[1]
|
|
|
+ + this.columnWidths[2];
|
|
|
+ final int w4to5 = this.columnWidths[4] + this.columnGaps[4]
|
|
|
+ + this.columnWidths[5];
|
|
|
+ final int w1to4 = w1to2 + this.columnGaps[2] + this.columnWidths[3]
|
|
|
+ + this.columnGaps[3] + this.columnWidths[4];
|
|
|
+ final int w1to5 = w1to4 + this.columnGaps[4] + this.columnWidths[5];
|
|
|
+ final int w0to5 = w1to5 + this.columnWidths[0] + this.columnGaps[0];
|
|
|
+ for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
|
|
|
+ final int format
|
|
|
+ = this.rowFormats[rowIndex % this.rowFormats.length];
|
|
|
+
|
|
|
+ switch (format) {
|
|
|
+ case FormatLayout.C:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(rowX[0], rowY, w0to5,
|
|
|
+ c0.getPreferredSize().height);
|
|
|
+ componentIndex = componentIndex + 1;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(
|
|
|
+ rowX[0],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c0.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[0], c0.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c1.setBounds(
|
|
|
+ rowX[1],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c1.getPreferredSize().height) / 2,
|
|
|
+ w1to5, c1.getPreferredSize().height
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 2;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(
|
|
|
+ rowX[0],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c0.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[0], c0.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c1.setBounds(
|
|
|
+ rowX[1],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c1.getPreferredSize().height) / 2,
|
|
|
+ w1to4, c1.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c2.setBounds(
|
|
|
+ rowX[5],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c2.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[5], c2.getPreferredSize().height
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 3;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(
|
|
|
+ rowX[0],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c0.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[0], c0.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c1.setBounds(
|
|
|
+ rowX[1],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c1.getPreferredSize().height) / 2,
|
|
|
+ w1to2, c1.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c2.setBounds(
|
|
|
+ rowX[3],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c2.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[3], c2.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c3.setBounds(
|
|
|
+ rowX[4],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c3.getPreferredSize().height) / 2,
|
|
|
+ w4to5, c3.getPreferredSize().height
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 4;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLC:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(
|
|
|
+ rowX[0],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c0.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[0], c0.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c1.setBounds(
|
|
|
+ rowX[1],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c1.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[1], c1.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c2.setBounds(
|
|
|
+ rowX[2],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c2.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[2], c2.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c3.setBounds(
|
|
|
+ rowX[3],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c3.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[3], c3.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ c4.setBounds(
|
|
|
+ rowX[4],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c4.getPreferredSize().height) / 2,
|
|
|
+ w4to5, c4.getPreferredSize().height
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(
|
|
|
+ rowX[0],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c0.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[0], c0.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c1.setBounds(
|
|
|
+ rowX[1],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c1.getPreferredSize().height) / 2,
|
|
|
+ w1to2, c1.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c2.setBounds(
|
|
|
+ rowX[3],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c2.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[3], c2.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c3.setBounds(
|
|
|
+ rowX[4],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c3.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[4], c3.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ c4.setBounds(
|
|
|
+ rowX[5],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c4.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[5], c4.getPreferredSize().height
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 5;
|
|
|
+ break;
|
|
|
+ case FormatLayout.LCBLCB:
|
|
|
+ c0 = parent.getComponent(componentIndex);
|
|
|
+ c0.setBounds(
|
|
|
+ rowX[0],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c0.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[0], c0.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c1 = parent.getComponent(componentIndex + 1);
|
|
|
+ c1.setBounds(
|
|
|
+ rowX[1],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c1.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[1], c1.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c2 = parent.getComponent(componentIndex + 2);
|
|
|
+ c2.setBounds(
|
|
|
+ rowX[2],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c2.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[2], c2.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c3 = parent.getComponent(componentIndex + 3);
|
|
|
+ c3.setBounds(
|
|
|
+ rowX[3],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c3.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[3], c3.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c4 = parent.getComponent(componentIndex + 4);
|
|
|
+ c4.setBounds(
|
|
|
+ rowX[4],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c4.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[4], c4.getPreferredSize().height
|
|
|
+ );
|
|
|
+ c5 = parent.getComponent(componentIndex + 5);
|
|
|
+ c5.setBounds(
|
|
|
+ rowX[5],
|
|
|
+ rowY + (this.rowHeights[rowIndex]
|
|
|
+ - c5.getPreferredSize().height) / 2,
|
|
|
+ this.columnWidths[5], c5.getPreferredSize().height
|
|
|
+ );
|
|
|
+ componentIndex = componentIndex + 6;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ rowY = rowY + this.rowHeights[rowIndex] + this.rowGap;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'C' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ */
|
|
|
+ protected void updateC(final int rowIndex, final Dimension d0) {
|
|
|
+ this.rowHeights[rowIndex] = d0.height;
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columns0to5Width = Math.max(this.columns0to5Width, d0.width);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'LC' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ * @param d1 dimension 1.
|
|
|
+ */
|
|
|
+ protected void updateLC(final int rowIndex, final Dimension d0,
|
|
|
+ final Dimension d1) {
|
|
|
+
|
|
|
+ this.rowHeights[rowIndex] = Math.max(d0.height, d1.height);
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
|
|
|
+ this.columns1to5Width = Math.max(this.columns1to5Width, d1.width);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'LCB' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ * @param d1 dimension 1.
|
|
|
+ * @param d2 dimension 2.
|
|
|
+ */
|
|
|
+ protected void updateLCB(final int rowIndex,
|
|
|
+ final Dimension d0, final Dimension d1,
|
|
|
+ final Dimension d2) {
|
|
|
+
|
|
|
+ this.rowHeights[rowIndex]
|
|
|
+ = Math.max(d0.height, Math.max(d1.height, d2.height));
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
|
|
|
+ this.columns1to4Width = Math.max(this.columns1to4Width, d1.width);
|
|
|
+ this.columnWidths[5] = Math.max(this.columnWidths[5], d2.width);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'LCLC' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ * @param d1 dimension 1.
|
|
|
+ * @param d2 dimension 2.
|
|
|
+ * @param d3 dimension 3.
|
|
|
+ */
|
|
|
+ protected void updateLCLC(final int rowIndex, final Dimension d0,
|
|
|
+ final Dimension d1, final Dimension d2,
|
|
|
+ final Dimension d3) {
|
|
|
+
|
|
|
+ this.rowHeights[rowIndex] = Math.max(Math.max(d0.height, d1.height),
|
|
|
+ Math.max(d2.height, d3.height));
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
|
|
|
+ this.columns1and2Width = Math.max(this.columns1and2Width, d1.width);
|
|
|
+ this.columnWidths[3] = Math.max(this.columnWidths[3], d2.width);
|
|
|
+ this.columns4and5Width = Math.max(this.columns4and5Width, d3.width);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'LCBLC' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ * @param d1 dimension 1.
|
|
|
+ * @param d2 dimension 2.
|
|
|
+ * @param d3 dimension 3.
|
|
|
+ * @param d4 dimension 4.
|
|
|
+ */
|
|
|
+ protected void updateLCBLC(final int rowIndex, final Dimension d0,
|
|
|
+ final Dimension d1, final Dimension d2,
|
|
|
+ final Dimension d3, final Dimension d4) {
|
|
|
+
|
|
|
+ this.rowHeights[rowIndex] = (Math.max(
|
|
|
+ d0.height,
|
|
|
+ Math.max(Math.max(d1.height, d2.height),
|
|
|
+ Math.max(d3.height, d4.height)))
|
|
|
+ );
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
|
|
|
+ this.columnWidths[1] = Math.max(this.columnWidths[1], d1.width);
|
|
|
+ this.columnWidths[2] = Math.max(this.columnWidths[2], d2.width);
|
|
|
+ this.columnWidths[3] = Math.max(this.columnWidths[3], d3.width);
|
|
|
+ this.columns4and5Width = Math.max(this.columns4and5Width, d4.width);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'LCLCB' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ * @param d1 dimension 1.
|
|
|
+ * @param d2 dimension 2.
|
|
|
+ * @param d3 dimension 3.
|
|
|
+ * @param d4 dimension 4.
|
|
|
+ */
|
|
|
+ protected void updateLCLCB(final int rowIndex, final Dimension d0,
|
|
|
+ final Dimension d1, final Dimension d2,
|
|
|
+ final Dimension d3, final Dimension d4) {
|
|
|
+
|
|
|
+ this.rowHeights[rowIndex] = (Math.max(d0.height,
|
|
|
+ Math.max(Math.max(d1.height, d2.height),
|
|
|
+ Math.max(d3.height, d4.height))));
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
|
|
|
+ this.columns1and2Width = Math.max(this.columns1and2Width, d1.width);
|
|
|
+ this.columnWidths[3] = Math.max(this.columnWidths[3], d2.width);
|
|
|
+ this.columnWidths[4] = Math.max(this.columnWidths[4], d3.width);
|
|
|
+ this.columnWidths[5] = Math.max(this.columnWidths[5], d4.width);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Processes a row in 'LCBLCB' format.
|
|
|
+ *
|
|
|
+ * @param rowIndex the row index.
|
|
|
+ * @param d0 dimension 0.
|
|
|
+ * @param d1 dimension 1.
|
|
|
+ * @param d2 dimension 2.
|
|
|
+ * @param d3 dimension 3.
|
|
|
+ * @param d4 dimension 4.
|
|
|
+ * @param d5 dimension 5.
|
|
|
+ */
|
|
|
+ protected void updateLCBLCB(final int rowIndex,
|
|
|
+ final Dimension d0, final Dimension d1,
|
|
|
+ final Dimension d2,
|
|
|
+ final Dimension d3, final Dimension d4,
|
|
|
+ final Dimension d5) {
|
|
|
+
|
|
|
+ this.rowHeights[rowIndex] = Math.max(
|
|
|
+ Math.max(d0.height, d1.height),
|
|
|
+ Math.max(Math.max(d2.height, d3.height),
|
|
|
+ Math.max(d4.height, d5.height))
|
|
|
+ );
|
|
|
+ this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
|
|
|
+ this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
|
|
|
+ this.columnWidths[1] = Math.max(this.columnWidths[1], d1.width);
|
|
|
+ this.columnWidths[2] = Math.max(this.columnWidths[2], d2.width);
|
|
|
+ this.columnWidths[3] = Math.max(this.columnWidths[3], d3.width);
|
|
|
+ this.columnWidths[4] = Math.max(this.columnWidths[4], d4.width);
|
|
|
+ this.columnWidths[5] = Math.max(this.columnWidths[5], d5.width);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Finishes of the processing.
|
|
|
+ */
|
|
|
+ public void complete() {
|
|
|
+
|
|
|
+ this.columnWidths[1] = Math.max(
|
|
|
+ this.columnWidths[1],
|
|
|
+ this.columns1and2Width - this.columnGaps[1] - this.columnWidths[2]
|
|
|
+ );
|
|
|
+
|
|
|
+ this.columnWidths[4] = Math.max(
|
|
|
+ this.columnWidths[4],
|
|
|
+ Math.max(
|
|
|
+ this.columns4and5Width - this.columnGaps[4]
|
|
|
+ - this.columnWidths[5],
|
|
|
+ Math.max(
|
|
|
+ this.columns1to4Width - this.columnGaps[1]
|
|
|
+ - this.columnGaps[2] - this.columnGaps[3]
|
|
|
+ - this.columnWidths[1] - this.columnWidths[2]
|
|
|
+ - this.columnWidths[3],
|
|
|
+ this.columns1to5Width - this.columnGaps[1]
|
|
|
+ - this.columnGaps[2] - this.columnGaps[3]
|
|
|
+ - this.columnWidths[1] - this.columnWidths[2]
|
|
|
+ - this.columnWidths[3] - this.columnGaps[4]
|
|
|
+ )
|
|
|
+ )
|
|
|
+ );
|
|
|
+
|
|
|
+ int leftWidth = this.columnWidths[0] + this.columnGaps[0]
|
|
|
+ + this.columnWidths[1] + this.columnGaps[1]
|
|
|
+ + this.columnWidths[2];
|
|
|
+
|
|
|
+ int rightWidth = this.columnWidths[3] + this.columnGaps[3]
|
|
|
+ + this.columnWidths[4] + this.columnGaps[4]
|
|
|
+ + this.columnWidths[5];
|
|
|
+
|
|
|
+ if (splitLayout()) {
|
|
|
+ if (leftWidth > rightWidth) {
|
|
|
+ final int mismatch = leftWidth - rightWidth;
|
|
|
+ this.columnWidths[4] = this.columnWidths[4] + mismatch;
|
|
|
+ rightWidth = rightWidth + mismatch;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ final int mismatch = rightWidth - leftWidth;
|
|
|
+ this.columnWidths[1] = this.columnWidths[1] + mismatch;
|
|
|
+ leftWidth = leftWidth + mismatch;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ this.totalWidth = leftWidth + this.columnGaps[2] + rightWidth;
|
|
|
+
|
|
|
+ if (this.columns0to5Width > this.totalWidth) {
|
|
|
+ final int spaceToAdd = (this.columns0to5Width - this.totalWidth);
|
|
|
+ if (splitLayout()) {
|
|
|
+ final int halfSpaceToAdd = spaceToAdd / 2;
|
|
|
+ this.columnWidths[1] = this.columnWidths[1] + halfSpaceToAdd;
|
|
|
+ this.columnWidths[4] = this.columnWidths[4] + spaceToAdd
|
|
|
+ - halfSpaceToAdd;
|
|
|
+ this.totalWidth = this.totalWidth + spaceToAdd;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ this.columnWidths[1] = this.columnWidths[1] + spaceToAdd;
|
|
|
+ this.totalWidth = this.totalWidth + spaceToAdd;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns true if this layout involves a split into two sections.
|
|
|
+ *
|
|
|
+ * @return <code>true</code> if this layout involves a split into two
|
|
|
+ * sections.
|
|
|
+ */
|
|
|
+ private boolean splitLayout() {
|
|
|
+ for (int i = 0; i < this.rowFormats.length; i++) {
|
|
|
+ if (this.rowFormats[i] > FormatLayout.LCB) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Not used.
|
|
|
+ *
|
|
|
+ * @param comp the component.
|
|
|
+ */
|
|
|
+ public void addLayoutComponent(final Component comp) {
|
|
|
+ // not used
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Not used.
|
|
|
+ *
|
|
|
+ * @param comp the component.
|
|
|
+ */
|
|
|
+ public void removeLayoutComponent(final Component comp) {
|
|
|
+ // not used
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Not used.
|
|
|
+ *
|
|
|
+ * @param name the component name.
|
|
|
+ * @param comp the component.
|
|
|
+ */
|
|
|
+ public void addLayoutComponent(final String name, final Component comp) {
|
|
|
+ // not used
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Not used.
|
|
|
+ *
|
|
|
+ * @param name the component name.
|
|
|
+ * @param comp the component.
|
|
|
+ */
|
|
|
+ public void removeLayoutComponent(final String name, final Component comp) {
|
|
|
+ // not used
|
|
|
+ }
|
|
|
+
|
|
|
+}
|