TableLayout

java.lang.Object
- com.fr.design.layout.TableLayout

所有已实现的接口:

java.awt.LayoutManager, java.awt.LayoutManager2, java.io.Serializable
```
public class TableLayout
extends java.lang.Object
implements java.awt.LayoutManager2, java.io.Serializable
```
TableLayout is a layout manager that is more powerful than GridBagLayout yet much easier to use.
Background
TableLayout is a layout manager that arranges components in rows and columns like a spreadsheet. TableLayout allows each row or column to be a different size. A row or column can be given an absolute size in pixels, a percentage of the available space, or it can grow and shrink to fill the remaining space after other rows and columns have been resized.

Using spreadsheet terminology, a cell is the intersection of a row and column. Cells have finite, non-negative sizes measured in pixels. The dimensions of a cell depend solely upon the dimensions of its row and column.

A component occupies a rectangular group of one or more cells. The component can be aligned within those cells using four vertical and six horizontal justifications. The vertical justifications are left, center, right, and full. The horizontal justifications are left, center, right, full, leading, and trailing. With full justification the component is stretched either vertically or horizontally to fit the cell or group of cells.
Justification
Leading and trailing justification are used to support languages that are read from right to left. See the java.awt.ComponentOrientation class for details and http://java.sun.com/products/jfc/tsc/articles/bidi for an introduction to component orientation and bidirectional text support. The leading justification will align the component along the leading edge of the container and the trailing justification will align the component along the trailing edge. There is no leading or trailing justification along the vertical axis since all modern languages are read from top to bottom and no bottom-to-top orientation is defined in java.awt.ComponentOrientation.

For components using the ComponentOrientation.LEFT_TO_RIGHT orientation, the leading edge is the left edge and the trailing edge is the right one. For components using the ComponentOrientation.RIGHT_TO_LEFT orientation, the opposite is true. For components that are using ComponentOrientation.UNKNOWN and for Java runtime environments that do not support component orientation, left-to-right orientation is assumed for backwards compatibility.
Gaps
Horizontal and vertical gaps can be placed between rows and columns in two ways. If uniformed gaps are desired, the setHGap and setVGap methods may be used. To vary the size of gaps, simply use empty rows and columns with absolute sizes. Similiarly, to make a border around a container that does not have insets, use empty rows and columns along the edges of the container.
Constraints
Using TableLayout is a simple two step process. First, create a grid for your container by specifying row and column sizes using either a TableLayout constructor or the insertRow and insertColumn methods. Second, add components to the cells formed by the rows and columns.

When adding a component to a container that uses TableLayout, you specify the component's constraints that state which cells the component will occupy and how the component will be aligned. The constraints can be specified into two ways. The TableLayoutConstraints class can be used to systematically specify the constraints. This is useful to dynamic code, bean builders, and rapid application development software.

For manual coding, a quicker and easier way to specify constraints is with a short string in the form "x1, y1, x2, y2, hAlign, vAlign" where (x1, y1) identifies the top left cell (column x1, row y1) for the component and (x2, y2) identfies the bottom right cell. x2 and y2 are optional. If they are not specified, the component will occupy only one cell, (x1, y1). hAlign and vAlign are also optional with default values of full justification. Alignments may be spelt fully as in "LEFT" or abbreviated as in "L". The text is not case sensitive, but it is recommended that uppercase is used for two reasons. First, these text values are in essence constants. Second, some fonts use the same glyphs for representing a lowercase L and the number one. Ex., "l" vs. "1". Even fonts that do not will often use similar glyphs so using uppercase avoids confusion.
Dynamically altering the layout
Rows and columns can be dynamically created, resized, and removed at any time, even if the container is visible. Components will be shifted appropriately as rows and columns are inserted or removed, just as cells are shifted in a spreadsheet.

Rows and columns can be made "hidden" or effectively invisible by setting their size to zero. They can be shown again by setting their size back to a non-zero value. This is very useful for toggle form elements without having to remove individual components.
Preferred sizes
Often it is desireable to make a row or column just large enough to ensure that all components contained partially or wholly in that row or column are their preferred size. To make this easy, there is a constant called PREFERRED that can be used to specify row or column sizes. There is another constant called MINIMUM that does a similar task using components' minimum sizes instead of their preferred sizes.

There is no corresponding MAXIMUM constant for several reasons. First, it is mathematically impossible to honor both the minimum and maximum sizes of more than one component when conflicts arise. For example, say components a and b are in the same row. If a's maximum height is less than b's minimum height, then one of these constraints must be violated. Since TableLayout is a complete, general Cartesian layout manager, it would be possible to specify conflicting constraints if a MAXIMUM constant existed.

Second, the ability to make a component grow up to a maximum size is primarily of interest to layout managers like SpringLayout that have to balance the sizes of components because the presence of one component affects the size of another. Other than the effect of preferred and minimum size rows/columns, which are essentially convenient ways of specifying absolute sizes, the existence and constraints of one component does not affect any other components when using TableLayout. This is accomplished because rows and columns are explicit in TableLayout.

Third, the ability to constrain a component to its maximum size is subsumed by the ability to constrain it to its preferred size, which is precisely what happens when a component is aligned using anything but full justification. In the case of full justification, the component's maximum size is by definition unbounded.
Example
```
 import java.awt.*;
 import javax.swing.*;
 import com.fr.design.core.layout.TableLayout;
 
 public class Preferred extends JFrame
 {
 
     public static void main (String args[])
     {
         new Preferred();
     }
 
     public Preferred ()
     {
         super("The Power of Preferred Sizes");
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         Container pane = getContentPane();
 
         // b - border
         // f - FILL
         // p - PREFERRED
         // vs - vertical space between labels and text fields
         // vg - vertical gap between form elements
         // hg - horizontal gap between form elements
 
         double b = 10;
         double f = TableLayout.FILL;
         double p = TableLayout.PREFERRED;
         double vs = 5;
         double vg = 10;
         double hg = 10;
 
         double size[][] =
             {{b, f, hg, p, hg, p, b},
              {b, p, vs, p, vg, p, vs, p, vg, p, vs, p, vg, p, b}};
 
         TableLayout layout = new TableLayout(size);
         pane.setLayout (layout);
 
         // Create all controls
         UILabel labelName    = new UILabel("Name");
         UILabel labelAddress = new UILabel("Address");
         UILabel labelCity    = new UILabel("City");
         UILabel labelState   = new UILabel("State");
         UILabel labelZip     = new UILabel("Zip");
 
         UITextField textfieldName    = new UITextField(10);
         UITextField textfieldAddress = new UITextField(20);
         UITextField textfieldCity    = new UITextField(10);
         UITextField textfieldState   = new UITextField(2);
         UITextField textfieldZip     = new UITextField(5);
 
         UIButton buttonOk = new UIButton("OK");
         UIButton buttonCancel = new UIButton("Cancel");
         JPanel panelButton = newJPanel();
         panelButton.add(buttonOk);
         panelButton.add(buttonCancel);
 
         // Add all controls
         pane.add(labelName,        "1,  1, 5, 1");
         pane.add(textfieldName,    "1,  3, 5, 3");
         pane.add(labelAddress,     "1,  5, 5, 5");
         pane.add(textfieldAddress, "1,  7, 5, 7");
         pane.add(labelCity,        "1,  9");
         pane.add(textfieldCity,    "1, 11");
         pane.add(labelState,       "3,  9");
         pane.add(textfieldState,   "3, 11");
         pane.add(labelZip,         "5,  9");
         pane.add(textfieldZip,     "5, 11");
         pane.add(panelButton,      "1, 13, 5, 13");
 
         pack();
         show();
     }
 }
 
```
另请参阅:
序列化表格

嵌套类概要

嵌套类
限定符和类型类和说明

static class TableLayout.Entry

嵌套类
限定符和类型	类和说明
`static class`	`TableLayout.Entry`

字段概要

字段
限定符和类型	字段和说明
`static int`	`BOTTOM` Indicates that the component is bottom justified in its cell
`protected static int`	`C` Indicates a column
`static int`	`CENTER` Indicates that the component is centered in its cell
`protected static boolean`	`checkForComponentOrientationSupport` Used to minimize reflection calls
`protected int[][]`	`crOffset` Offsets of crs in pixels.
`protected int[][]`	`crSize` Sizes of crs in pixels
`protected double[][]`	`crSpec` Sizes of crs expressed in absolute and relative terms
`protected static double[][]`	`defaultSize` Default row/column size
`protected boolean`	`dirty` Indicates whether or not the size of the cells are known for the last known size of the container.
`static double`	`FILL` Indicates that the row/column should fill the available space
`static int`	`FULL` Indicates that the component is full justified in its cell
`protected int`	`hGap` Horizontal gap between columns
`static int`	`LEADING` Indicates that the component is leading justified in its cell.
`static int`	`LEFT` Indicates that the component is left justified in its cell
`protected java.util.LinkedList<TableLayout.Entry>`	`list` List of components and their sizes
`protected static java.lang.reflect.Method`	`methodGetComponentOrientation` Method used to get component orientation while preserving compatability with earlier versions of java.awt.Container.
`static double`	`MINIMUM` Indicates that the row/column should be allocated just enough space to accomidate the minimum size of all components contained completely within this row/column.
`protected int`	`oldHeight` Previous known height of the container
`protected int`	`oldWidth` Previous known width of the container
`static double`	`PREFERRED` Indicates that the row/column should be allocated just enough space to accomidate the preferred size of all components contained completely within this row/column.
`protected static int`	`R` Indicates a row
`static int`	`RIGHT` Indicates that the component is right justified in its cell
`static int`	`TOP` Indicates that the component is top justified in its cell
`static int`	`TRAILING` Indicates that the component is trailing justified in its cell.
`protected int`	`vGap` Vertical gap between rows

构造器概要

构造器
构造器和说明
`TableLayout()` Constructs an instance of TableLayout.
`TableLayout(double[][] size)` Constructs an instance of TableLayout.
`TableLayout(double[] col, double[] row)` Constructs an instance of TableLayout.

方法概要

方法
限定符和类型	方法和说明
`void`	`addLayoutComponent(java.awt.Component component, java.lang.Object constraint)` Adds the specified component with the specified name to the layout.
`void`	`addLayoutComponent(java.lang.String name, java.awt.Component component)` Adds the specified component with the specified name to the layout.
`protected int`	`assignAbsoluteSize(int z, int availableSize)` Assigns absolute sizes.
`protected void`	`assignFillSize(int z, int availableSize)` Assigns FILL sizes.
`protected int`	`assignPrefMinSize(int z, int availableSize, double typeOfSize)` Assigned sizes to preferred and minimum size columns and rows.
`protected int`	`assignRelativeSize(int z, int availableSize)` Assigns relative sizes.
`protected java.awt.Dimension`	`calculateLayoutSize(java.awt.Container container, double typeOfSize)` Calculates the preferred or minimum size for the methods preferredLayoutSize and minimumLayoutSize.
`protected int`	`calculateLayoutSize(java.awt.Container container, int z, double typeOfSize, TableLayout.Entry[] entryList, java.awt.Dimension[] prefMinSize)` Calculates the preferred or minimum size for the method calculateLayoutSize(Container container, double typeOfSize).
`protected void`	`calculateOffset(int z, java.awt.Insets inset)` Calculates the offset of each cr.
`protected void`	`calculateSize(java.awt.Container container)` Calculates the sizes of the rows and columns based on the absolute and relative sizes specified in `crSpec[R]` and `crSpec[C]` and the size of the container.
`protected int[]`	`calculateSizeAndOffset(TableLayout.Entry entry, int preferredSize, boolean isColumn)` Calculates the vertical/horizontal offset and size of a component.
`void`	`deleteColumn(int i)` Deletes a column in this layout.
`protected void`	`deleteCr(int z, int i)` Deletes a cr for the methods deleteRow or deleteColumn.
`void`	`deleteRow(int i)` Deletes a row in this layout.
`double[]`	`getColumn()` Gets the sizes of columns in this layout.
`double`	`getColumn(int i)` Gets the width of a single column in this layout.
`protected java.awt.ComponentOrientation`	`getComponentOrientation(java.awt.Container container)` Gets the container's component orientation.
`TableLayoutConstraints`	`getConstraints(java.awt.Component component)` Gets the constraints of a given component.
`int`	`getHGap()` Gets the horizontal gap between colunns.
`java.util.List<TableLayout.Entry>`	`getInvalidEntry()` Determines whether or not there are any components with invalid constraints.
`float`	`getLayoutAlignmentX(java.awt.Container parent)` Returns the alignment along the x axis.
`float`	`getLayoutAlignmentY(java.awt.Container parent)` Returns the alignment along the y axis.
`int`	`getNumColumn()` Gets the number of columns in this layout.
`int`	`getNumRow()` Gets the number of rows in this layout.
`java.util.List<TableLayout.Entry>`	`getOverlappingEntry()` Gets a list of overlapping components and their constraints.
`double[]`	`getRow()` Gets the height of a single row in this layout.
`double`	`getRow(int i)` Gets the sizes of a row in this layout.
`int`	`getVGap()` Gets the vertical gap between rows.
`protected void`	`init(double[] col, double[] row)` Initializes the TableLayout for all constructors.
`void`	`insertColumn(int i, double size)` Inserts a column in this layout.
`void`	`insertCr(int z, int i, double size)` Inserts a cr for the methods insertRow or insertColumn.
`void`	`insertRow(int i, double size)` Inserts a row in this layout.
`void`	`invalidateLayout(java.awt.Container target)` Invalidates the layout, indicating that if the layout manager has cached information it should be discarded.
`void`	`layoutContainer(java.awt.Container container)` To lay out the specified container using this layout.
`java.awt.Dimension`	`maximumLayoutSize(java.awt.Container target)` Returns the maximum dimensions for this layout given the components in the specified target container.
`java.awt.Dimension`	`minimumLayoutSize(java.awt.Container container)` Determines the minimum size of the container argument using this layout.
`java.awt.Dimension`	`preferredLayoutSize(java.awt.Container container)` Determines the preferred size of the container argument using this layout.
`void`	`removeLayoutComponent(java.awt.Component component)` Removes the specified component from the layout.
`void`	`setColumn(double[] column)` Adjusts the number and sizes of rows in this layout.
`void`	`setColumn(int i, double size)` Adjusts the width of a single column in this layout.
`void`	`setConstraints(java.awt.Component component, TableLayoutConstraints constraint)` Sets the constraints of a given component.
`protected void`	`setCr(int z, double[] size)` Sets the sizes of rows or columns for the methods setRow or setColumn.
`protected void`	`setCr(int z, int i, double size)` Sets the sizes of rows or columns for the methods setRow or setColumn.
`void`	`setHGap(int hGap)` Sets the horizontal gap between colunns.
`void`	`setRow(double[] row)` Adjusts the number and sizes of rows in this layout.
`void`	`setRow(int i, double size)` Adjusts the height of a single row in this layout.
`void`	`setVGap(int vGap)` Sets the vertical gap between rows.
`java.lang.String`	`toString()` Converts this TableLayout to a string.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - defaultSize
```
protected static final double[][] defaultSize
```
    Default row/column size
  - C
```
protected static final int C
```
    Indicates a column
    
    另请参阅:
    常量字段值
  - R
```
protected static final int R
```
    Indicates a row
    
    另请参阅:
    常量字段值
  - checkForComponentOrientationSupport
```
protected static boolean checkForComponentOrientationSupport
```
    Used to minimize reflection calls
  - methodGetComponentOrientation
```
protected static java.lang.reflect.Method methodGetComponentOrientation
```
    Method used to get component orientation while preserving compatability with earlier versions of java.awt.Container. Necessary for supporting older JDKs and MicroEdition versions of Java.
  - crSpec
```
protected double[][] crSpec
```
    Sizes of crs expressed in absolute and relative terms
  - crSize
```
protected int[][] crSize
```
    Sizes of crs in pixels
  - crOffset
```
protected int[][] crOffset
```
    Offsets of crs in pixels. The left boarder of column n is at crOffset[C][n] and the right boarder is at cr[C][n + 1] for all columns including the last one. crOffset[C].length = crSize[C].length + 1
  - list
```
protected java.util.LinkedList<TableLayout.Entry> list
```
    List of components and their sizes
  - dirty
```
protected boolean dirty
```
    Indicates whether or not the size of the cells are known for the last known size of the container. If dirty is true or the container has been resized, the cell sizes must be recalculated using calculateSize.
  - oldWidth
```
protected int oldWidth
```
    Previous known width of the container
  - oldHeight
```
protected int oldHeight
```
    Previous known height of the container
  - hGap
```
protected int hGap
```
    Horizontal gap between columns
  - vGap
```
protected int vGap
```
    Vertical gap between rows
  - LEFT
```
public static final int LEFT
```
    Indicates that the component is left justified in its cell
    
    另请参阅:
    常量字段值
  - TOP
```
public static final int TOP
```
    Indicates that the component is top justified in its cell
    
    另请参阅:
    常量字段值
  - CENTER
```
public static final int CENTER
```
    Indicates that the component is centered in its cell
    
    另请参阅:
    常量字段值
  - FULL
```
public static final int FULL
```
    Indicates that the component is full justified in its cell
    
    另请参阅:
    常量字段值
  - BOTTOM
```
public static final int BOTTOM
```
    Indicates that the component is bottom justified in its cell
    
    另请参阅:
    常量字段值
  - RIGHT
```
public static final int RIGHT
```
    Indicates that the component is right justified in its cell
    
    另请参阅:
    常量字段值
  - LEADING
```
public static final int LEADING
```
    Indicates that the component is leading justified in its cell. Leading justification means components are left justified if their container is left-oriented and right justified if their container is right-oriented. Trailing justification is opposite. see java.awt.Component#getComponentOrientation
    
    另请参阅:
    常量字段值
  - TRAILING
```
public static final int TRAILING
```
    Indicates that the component is trailing justified in its cell. Trailing justification means components are right justified if their container is left-oriented and left justified if their container is right-oriented. Leading justification is opposite. see java.awt.Component#getComponentOrientation
    
    另请参阅:
    常量字段值
  - FILL
```
public static final double FILL
```
    Indicates that the row/column should fill the available space
    
    另请参阅:
    常量字段值
  - PREFERRED
```
public static final double PREFERRED
```
    Indicates that the row/column should be allocated just enough space to accomidate the preferred size of all components contained completely within this row/column.
    
    另请参阅:
    常量字段值
  - MINIMUM
```
public static final double MINIMUM
```
    Indicates that the row/column should be allocated just enough space to accomidate the minimum size of all components contained completely within this row/column.
    
    另请参阅:
    常量字段值
- 构造器详细资料
  - TableLayout
```
public TableLayout()
```
    Constructs an instance of TableLayout. This TableLayout will have no columns or rows. This constructor is most useful for bean-oriented programming and dynamically adding columns and rows.
  - TableLayout
```
public TableLayout(double[][] size)
```
    Constructs an instance of TableLayout.
    
    参数:
    size - widths of columns and heights of rows in the format, {{col0, col1, col2, ..., colN}, {row0, row1, row2, ..., rowM}} If this parameter is invalid, the TableLayout will have exactly one row and one column.
  - TableLayout
```
public TableLayout(double[] col,
           double[] row)
```
    Constructs an instance of TableLayout.
    
    参数:
    col - widths of columns in the format, {{col0, col1, col2, ..., colN}
    row - heights of rows in the format, {{row0, row1, row2, ..., rowN}
- 方法详细资料
  - init
```
protected void init(double[] col,
        double[] row)
```
    Initializes the TableLayout for all constructors.
    
    参数:
    col - widths of columns in the format, {{col0, col1, col2, ..., colN}
    row - heights of rows in the format, {{row0, row1, row2, ..., rowN}
  - getConstraints
```
public TableLayoutConstraints getConstraints(java.awt.Component component)
```
    Gets the constraints of a given component.
    
    参数:
    component - desired component
    
    返回:
    If the given component is found, the constraints associated with that component. If the given component is null or is not found, null is returned.
  - setConstraints
```
public void setConstraints(java.awt.Component component,
                  TableLayoutConstraints constraint)
```
    Sets the constraints of a given component.
    
    参数:
    component - desired component. This parameter cannot be null.
    constraint - new set of constraints. This parameter cannot be null.
  - setColumn
```
public void setColumn(double[] column)
```
    Adjusts the number and sizes of rows in this layout. After calling this method, the caller should request this layout manager to perform the layout. This can be done with the following code:
```
     layout.layoutContainer(container);
     container.repaint();
 
```
    or
```
     window.pack()
 
```
    If this is not done, the changes in the layout will not be seen until the container is resized.
    参数:
    column - widths of each of the columns
    另请参阅:
    getColumn()
  - setRow
```
public void setRow(double[] row)
```
    Adjusts the number and sizes of rows in this layout. After calling this method, the caller should request this layout manager to perform the layout. This can be done with the following code: layout.layoutContainer(container); container.repaint(); or
```
     window.pack()
 
```
    If this is not done, the changes in the layout will not be seen until the container is resized.
    参数:
    row - heights of each of the rows. This parameter cannot be null.
    另请参阅:
    getRow()
  - setCr
```
protected void setCr(int z,
         double[] size)
```
    Sets the sizes of rows or columns for the methods setRow or setColumn.
    
    参数:
    z - indicates row or column
    size - new cr size
  - setColumn
```
public void setColumn(int i,
             double size)
```
    Adjusts the width of a single column in this layout. After calling this method, the caller should request this layout manager to perform the layout. This can be done with the following code: layout.layoutContainer(container); container.repaint(); or
```
     window.pack()
 
```
    If this is not done, the changes in the layout will not be seen until the container is resized.
    参数:
    i - zero-based index of column to set. If this parameter is not valid, an ArrayOutOfBoundsException will be thrown.
    size - width of the column. This parameter cannot be null.
    另请参阅:
    getColumn()
  - setRow
```
public void setRow(int i,
          double size)
```
    Adjusts the height of a single row in this layout. After calling this method, the caller should request this layout manager to perform the layout. This can be done with the following code: layout.layoutContainer(container); container.repaint(); or
```
     window.pack()
 
```
    If this is not done, the changes in the layout will not be seen until the container is resized.
    参数:
    i - zero-based index of row to set. If this parameter is not valid, an ArrayOutOfBoundsException will be thrown.
    size - height of the row. This parameter cannot be null.
    另请参阅:
    getRow()
  - setCr
```
protected void setCr(int z,
         int i,
         double size)
```
    Sets the sizes of rows or columns for the methods setRow or setColumn.
    
    参数:
    z - indicates row or column
    i - indicates which cr to resize
    size - new cr size
  - getColumn
```
public double[] getColumn()
```
    Gets the sizes of columns in this layout.
    
    返回:
    widths of each of the columns
    另请参阅:
    setColumn(double[])
  - getRow
```
public double[] getRow()
```
    Gets the height of a single row in this layout.
    
    返回:
    height of the requested row
    另请参阅:
    setRow(double[])
  - getColumn
```
public double getColumn(int i)
```
    Gets the width of a single column in this layout.
    
    参数:
    i - zero-based index of row to get. If this parameter is not valid, an ArrayOutOfBoundsException will be thrown.
    
    返回:
    width of the requested column
    另请参阅:
    setRow(double[])
  - getRow
```
public double getRow(int i)
```
    Gets the sizes of a row in this layout.
    
    参数:
    i - zero-based index of row to get. If this parameter is not valid, an ArrayOutOfBoundsException will be thrown.
    
    返回:
    height of each of the requested row
    另请参阅:
    setRow(double[])
  - getNumColumn
```
public int getNumColumn()
```
    Gets the number of columns in this layout.
    
    返回:
    the number of columns
  - getNumRow
```
public int getNumRow()
```
    Gets the number of rows in this layout.
    
    返回:
    the number of rows
  - getHGap
```
public int getHGap()
```
    Gets the horizontal gap between colunns.
    
    返回:
    the horizontal gap in pixels
  - getVGap
```
public int getVGap()
```
    Gets the vertical gap between rows.
    
    返回:
    the vertical gap in pixels
  - setHGap
```
public void setHGap(int hGap)
```
    Sets the horizontal gap between colunns.
    
    参数:
    hGap - the horizontal gap in pixels
  - setVGap
```
public void setVGap(int vGap)
```
    Sets the vertical gap between rows.
    
    参数:
    vGap - the horizontal gap in pixels
  - insertColumn
```
public void insertColumn(int i,
                double size)
```
    Inserts a column in this layout. All components to the right of the insertion point are moved right one column. The container will need to be laid out after this method returns. See setColumn.
    
    参数:
    i - zero-based index at which to insert the column
    size - size of the column to be inserted
    另请参阅:
    setColumn(double[]), deleteColumn(int)
  - insertRow
```
public void insertRow(int i,
             double size)
```
    Inserts a row in this layout. All components below the insertion point are moved down one row. The container will need to be laid out after this method returns. See setRow.
    
    参数:
    i - zero-based index at which to insert the row
    size - size of the row to be inserted
    另请参阅:
    setRow(double[]), deleteRow(int)
  - insertCr
```
public void insertCr(int z,
            int i,
            double size)
```
    Inserts a cr for the methods insertRow or insertColumn.
    
    参数:
    z - indicates row or column
    i - zero-based index at which to insert the cr
    size - size of cr being inserted
  - deleteColumn
```
public void deleteColumn(int i)
```
    Deletes a column in this layout. All components to the right of the deletion point are moved left one column. The container will need to be laid out after this method returns. See setColumn.
    
    参数:
    i - zero-based index of column to delete
    另请参阅:
    setColumn(double[]), deleteColumn(int)
  - deleteRow
```
public void deleteRow(int i)
```
    Deletes a row in this layout. All components below the deletion point are moved up one row. The container will need to be laid out after this method returns. See setRow. There must be at least two rows in order to delete a row.
    
    参数:
    i - zero-based index of row to delete
    另请参阅:
    setRow(double[]), deleteRow(int)
  - deleteCr
```
protected void deleteCr(int z,
            int i)
```
    Deletes a cr for the methods deleteRow or deleteColumn.
    
    参数:
    z - indicates row or column
    i - zero-based index of cr to delete
  - toString
```
public java.lang.String toString()
```
    Converts this TableLayout to a string.
    
    覆盖:
    
    toString 在类中 java.lang.Object
    
    返回:
    a string representing the columns and row sizes in the form "{{col0, col1, col2, ..., colN}, {row0, row1, row2, ..., rowM}}"
  - getInvalidEntry
```
public java.util.List<TableLayout.Entry> getInvalidEntry()
```
    Determines whether or not there are any components with invalid constraints. An invalid constraint is one that references a non-existing row or column. For example, on a table with five rows, row -1 and row 5 are both invalid. Valid rows are 0 through 4, inclusively. This method is useful for debugging.
    
    返回:
    a list of TableLayout.Entry instances refering to the invalid constraints and corresponding components
    另请参阅:
    getOverlappingEntry()
  - getOverlappingEntry
```
public java.util.List<TableLayout.Entry> getOverlappingEntry()
```
    Gets a list of overlapping components and their constraints. Two components overlap if they cover at least one common cell. This method is useful for debugging.
    
    返回:
    a list of zero or more TableLayout.Entry instances
    另请参阅:
    getInvalidEntry()
  - calculateSize
```
protected void calculateSize(java.awt.Container container)
```
    Calculates the sizes of the rows and columns based on the absolute and relative sizes specified in crSpec[R] and crSpec[C] and the size of the container. The result is stored in crSize[R] and crSize[C].
    
    参数:
    container - container using this TableLayout
  - assignAbsoluteSize
```
protected int assignAbsoluteSize(int z,
                     int availableSize)
```
    Assigns absolute sizes.
    
    参数:
    z - indicates row or column
    availableSize - amount of space available in the container
    
    返回:
    the amount of space available after absolute crs have been assigned sizes
  - assignRelativeSize
```
protected int assignRelativeSize(int z,
                     int availableSize)
```
    Assigns relative sizes.
    
    参数:
    z - indicates row or column
    availableSize - amount of space available in the container
    
    返回:
    the amount of space available after relative crs have been assigned sizes
  - assignFillSize
```
protected void assignFillSize(int z,
                  int availableSize)
```
    Assigns FILL sizes.
    
    参数:
    z - indicates row or column
    availableSize - amount of space available in the container
  - calculateOffset
```
protected void calculateOffset(int z,
                   java.awt.Insets inset)
```
    Calculates the offset of each cr.
    
    参数:
    z - indicates row or column
  - assignPrefMinSize
```
protected int assignPrefMinSize(int z,
                    int availableSize,
                    double typeOfSize)
```
    Assigned sizes to preferred and minimum size columns and rows. This reduces the available width and height. Minimum widths/heights must be calculated first because they affect preferred widths/heights, but not vice versa. The end result is that any component contained wholly or partly in a column/row of minimum/preferred width or height will get at least its minimum/preferred width or height, respectively.
    
    参数:
    z - indicates row or column
    availableSize - amount of space available in the container
    typeOfSize - indicates preferred or minimum
    
    返回:
    the amount of space available after absolute crs have been assigned sizes
  - layoutContainer
```
public void layoutContainer(java.awt.Container container)
```
    To lay out the specified container using this layout. This method reshapes the components in the specified target container in order to satisfy the constraints of all components.
    User code should not have to call this method directly.
    
    指定者:
    
    layoutContainer 在接口中 java.awt.LayoutManager
    
    参数:
    container - container being served by this layout manager
  - getComponentOrientation
```
protected java.awt.ComponentOrientation getComponentOrientation(java.awt.Container container)
```
    Gets the container's component orientation. If a JDK that does not support component orientation is being used, then null is returned.
    
    参数:
    container - Container whose orientation is being queried
    
    返回:
    the container's orientation or null if no orientation is supported
  - calculateSizeAndOffset
```
protected int[] calculateSizeAndOffset(TableLayout.Entry entry,
                           int preferredSize,
                           boolean isColumn)
```
    Calculates the vertical/horizontal offset and size of a component.
    
    参数:
    entry - entry containing component and contraints
    preferredSize - previously calculated preferred width/height of component
    isColumn - if true, this method is being called to calculate the offset/size of a column. if false,... of a row.
    
    返回:
    an array, a, of two integers such that a[0] is the offset and a[1] is the size
  - preferredLayoutSize
```
public java.awt.Dimension preferredLayoutSize(java.awt.Container container)
```
    Determines the preferred size of the container argument using this layout. The preferred size is the smallest size that, if used for the container's size, will ensure that all components are at least as large as their preferred size. This method cannot guarantee that all components will be their preferred size. For example, if component A and component B are each allocate half of the container's width and component A wants to be 10 pixels wide while component B wants to be 100 pixels wide, they cannot both be accommodated. Since in general components rather be larger than their preferred size instead of smaller, component B's request will be fulfilled. The preferred size of the container would be 200 pixels.
    
    指定者:
    
    preferredLayoutSize 在接口中 java.awt.LayoutManager
    
    参数:
    container - container being served by this layout manager
    
    返回:
    a dimension indicating the container's preferred size
  - minimumLayoutSize
```
public java.awt.Dimension minimumLayoutSize(java.awt.Container container)
```
    Determines the minimum size of the container argument using this layout. The minimum size is the smallest size that, if used for the container's size, will ensure that all components are at least as large as their minimum size. This method cannot guarantee that all components will be their minimum size. For example, if component A and component B are each allocate half of the container's width and component A wants to be 10 pixels wide while component B wants to be 100 pixels wide, they cannot both be accommodated. Since in general components rather be larger than their minimum size instead of smaller, component B's request will be fulfilled. The minimum size of the container would be 200 pixels.
    
    指定者:
    
    minimumLayoutSize 在接口中 java.awt.LayoutManager
    
    参数:
    container - container being served by this layout manager
    
    返回:
    a dimension indicating the container's minimum size
  - calculateLayoutSize
```
protected java.awt.Dimension calculateLayoutSize(java.awt.Container container,
                                     double typeOfSize)
```
    Calculates the preferred or minimum size for the methods preferredLayoutSize and minimumLayoutSize.
    
    参数:
    container - container whose size is being calculated
    typeOfSize - indicates preferred or minimum
    
    返回:
    a dimension indicating the container's preferred or minimum size
  - calculateLayoutSize
```
protected int calculateLayoutSize(java.awt.Container container,
                      int z,
                      double typeOfSize,
                      TableLayout.Entry[] entryList,
                      java.awt.Dimension[] prefMinSize)
```
    Calculates the preferred or minimum size for the method calculateLayoutSize(Container container, double typeOfSize). This method is passed the preferred/minimum sizes of the components so that the potentially expensive methods getPreferredSize()/getMinimumSize() are not called twice for the same component.
    
    参数:
    container - container whose size is being calculated
    z - indicates row or column
    typeOfSize - indicates preferred or minimum
    entryList - list of Entry objects
    prefMinSize - list of preferred or minimum sizes
    
    返回:
    a dimension indicating the container's preferred or minimum size
  - addLayoutComponent
```
public void addLayoutComponent(java.lang.String name,
                      java.awt.Component component)
```
    Adds the specified component with the specified name to the layout.
    
    指定者:
    
    addLayoutComponent 在接口中 java.awt.LayoutManager
    
    参数:
    name - indicates entry's position and anchor
    component - component to add
  - addLayoutComponent
```
public void addLayoutComponent(java.awt.Component component,
                      java.lang.Object constraint)
```
    Adds the specified component with the specified name to the layout.
    
    指定者:
    
    addLayoutComponent 在接口中 java.awt.LayoutManager2
    
    参数:
    component - component to add
    constraint - indicates entry's position and alignment
  - removeLayoutComponent
```
public void removeLayoutComponent(java.awt.Component component)
```
    Removes the specified component from the layout.
    
    指定者:
    
    removeLayoutComponent 在接口中 java.awt.LayoutManager
    
    参数:
    component - component being removed
  - maximumLayoutSize
```
public java.awt.Dimension maximumLayoutSize(java.awt.Container target)
```
    Returns the maximum dimensions for this layout given the components in the specified target container.
    
    指定者:
    
    maximumLayoutSize 在接口中 java.awt.LayoutManager2
    
    参数:
    target - the component which needs to be laid out
    
    返回:
    unconditionally, a Dimension of Integer.MAX_VALUE by Integer.MAX_VALUE since TableLayout does not limit the maximum size of a container
  - getLayoutAlignmentX
```
public float getLayoutAlignmentX(java.awt.Container parent)
```
    Returns the alignment along the x axis. This specifies how the component would like to be aligned relative to other components. The value should be a number between 0 and 1 where 0 represents alignment along the origin, 1 is aligned the furthest away from the origin, 0.5 is centered, etc.
    
    指定者:
    
    getLayoutAlignmentX 在接口中 java.awt.LayoutManager2
    
    返回:
    unconditionally, 0.5
  - getLayoutAlignmentY
```
public float getLayoutAlignmentY(java.awt.Container parent)
```
    Returns the alignment along the y axis. This specifies how the component would like to be aligned relative to other components. The value should be a number between 0 and 1 where 0 represents alignment along the origin, 1 is aligned the furthest away from the origin, 0.5 is centered, etc.
    
    指定者:
    
    getLayoutAlignmentY 在接口中 java.awt.LayoutManager2
    
    返回:
    unconditionally, 0.5
  - invalidateLayout
```
public void invalidateLayout(java.awt.Container target)
```
    Invalidates the layout, indicating that if the layout manager has cached information it should be discarded.
    
    指定者:
    
    invalidateLayout 在接口中 java.awt.LayoutManager2

类 TableLayout

嵌套类概要

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

defaultSize

C

R

checkForComponentOrientationSupport

methodGetComponentOrientation

crSpec

crSize

crOffset

list

dirty

oldWidth

oldHeight

hGap

vGap

LEFT

TOP

CENTER

FULL

BOTTOM

RIGHT

LEADING

TRAILING

FILL

PREFERRED

MINIMUM

构造器详细资料

TableLayout

TableLayout

TableLayout

方法详细资料

init

getConstraints

setConstraints

setColumn

setRow

setCr

setColumn

setRow

setCr

getColumn

getRow

getColumn

getRow

getNumColumn

getNumRow

getHGap

getVGap

setHGap

setVGap

insertColumn

insertRow

insertCr

deleteColumn

deleteRow

deleteCr

toString

getInvalidEntry

getOverlappingEntry

calculateSize

assignAbsoluteSize

assignRelativeSize

assignFillSize

calculateOffset

assignPrefMinSize

layoutContainer

getComponentOrientation

calculateSizeAndOffset

preferredLayoutSize

minimumLayoutSize

calculateLayoutSize

calculateLayoutSize

addLayoutComponent

addLayoutComponent