Package org.kuali.rice.krad.uif.layout

Class GridLayoutManagerBase

java.lang.Object
org.kuali.rice.krad.datadictionary.DictionaryBeanBase
org.kuali.rice.krad.datadictionary.uif.UifDictionaryBeanBase
org.kuali.rice.krad.uif.layout.LayoutManagerBase
org.kuali.rice.krad.uif.layout.GridLayoutManagerBase
All Implemented Interfaces:
Serializable, Cloneable, Copyable, DictionaryBean, UifDictionaryBean, GridLayoutManager, LayoutManager, LifecycleElement
public class GridLayoutManagerBase extends LayoutManagerBase implements GridLayoutManager
Layout manager that organizes its components in a table based grid

Items are laid out from left to right (with each item taking up one column) until the configured number of columns is reached. If the item count is greater than the number of columns, a new row will be created to render the remaining items (and so on until all items are placed). Labels for the fields can be pulled out (default) and rendered as a separate column. The manager also supports the column span and row span options for the field items. If not specified the default is 1.

Author:
Kuali Rice Team (rice.collab@kuali.org)
See Also:

  • Constructor Details

    • GridLayoutManagerBase

      public GridLayoutManagerBase()

  • Method Details

    • performFinalize

      public void performFinalize(Object model, LifecycleElement parent)
      The following finalization is performed:
      • If suppressLineWrapping is true, sets the number of columns to the container's items list size
      • Adjust the cell attributes for the container items
      The last phase before the view is rendered

      Here final preparations can be made based on the updated view state.

      Specified by:
      performFinalize in interface LifecycleElement
      Overrides:
      performFinalize in class LayoutManagerBase
      Parameters:
      model - - top level object containing the data
      parent - - parent component

    • setCellAttributes

      protected void setCellAttributes(Component component)
      Moves the width, align, and valign settings of the component to the corresponding cell properties (if not already configured)
      Parameters:
      component - instance to adjust settings for

    • getSupportedContainer

      public Class<? extends Container> getSupportedContainer()
      Description copied from class: LayoutManagerBase
      Default Impl Determines what Container classes are supported by the LayoutManager
      Specified by:
      getSupportedContainer in interface LayoutManager
      Overrides:
      getSupportedContainer in class LayoutManagerBase
      Returns:
      Classinvalid input: '<'? extends Container> container class supported
      See Also:

    • getNumberOfColumns

      public int getNumberOfColumns()
      Indicates the number of columns that should make up one row of data

      If the item count is greater than the number of columns, a new row will be created to render the remaining items (and so on until all items are placed).

      Note this does not include any generated columns by the layout manager, so the final column count could be greater (if label fields are separate).

      Specified by:
      getNumberOfColumns in interface GridLayoutManager
      Returns:
      int

    • setNumberOfColumns

      public void setNumberOfColumns(int numberOfColumns)
      Setter for the number of columns (each row)
      Specified by:
      setNumberOfColumns in interface GridLayoutManager
      Parameters:
      numberOfColumns -

    • isSuppressLineWrapping

      public boolean isSuppressLineWrapping()
      Indicates whether the number of columns for the table data should match the number of fields given in the container's items list (so that each field takes up one column without wrapping), this overrides the configured numberOfColumns

      If set to true during the initialize phase the number of columns will be set to the size of the container's field list, if false the configured number of columns is used

      Specified by:
      isSuppressLineWrapping in interface GridLayoutManager
      Returns:
      true if the column count should match the container's field count, false to use the configured number of columns

    • setSuppressLineWrapping

      public void setSuppressLineWrapping(boolean suppressLineWrapping)
      Setter for the suppressLineWrapping indicator
      Specified by:
      setSuppressLineWrapping in interface GridLayoutManager
      Parameters:
      suppressLineWrapping -

    • isApplyAlternatingRowStyles

      public boolean isApplyAlternatingRowStyles()
      Indicates whether alternating row styles should be applied

      Indicator to layout manager templates to apply alternating row styles. See the configured template for the actual style classes used

      Specified by:
      isApplyAlternatingRowStyles in interface GridLayoutManager
      Returns:
      true if alternating styles should be applied, false if all rows should have the same style

    • setApplyAlternatingRowStyles

      public void setApplyAlternatingRowStyles(boolean applyAlternatingRowStyles)
      Setter for the alternating row styles indicator
      Specified by:
      setApplyAlternatingRowStyles in interface GridLayoutManager
      Parameters:
      applyAlternatingRowStyles -

    • isApplyDefaultCellWidths

      public boolean isApplyDefaultCellWidths()
      Indicates whether the manager should default the cell widths

      If true, the manager will set the cell width by equally dividing by the number of columns

      Specified by:
      isApplyDefaultCellWidths in interface GridLayoutManager
      Returns:
      true if default cell widths should be applied, false if no defaults should be applied

    • setApplyDefaultCellWidths

      public void setApplyDefaultCellWidths(boolean applyDefaultCellWidths)
      Setter for the default cell width indicator
      Specified by:
      setApplyDefaultCellWidths in interface GridLayoutManager
      Parameters:
      applyDefaultCellWidths -

    • isRenderRowFirstCellHeader

      public boolean isRenderRowFirstCellHeader()
      Indicates whether the first cell of each row should be rendered as a header cell (th)

      When this flag is turned on, the first cell for each row will be rendered as a header cell. If GridLayoutManager.isRenderAlternatingHeaderColumns() is false, the remaining cells for the row will be rendered as data cells, else they will alternate between cell headers

      Specified by:
      isRenderRowFirstCellHeader in interface GridLayoutManager
      Returns:
      true if first cell of each row should be rendered as a header cell

    • setRenderRowFirstCellHeader

      public void setRenderRowFirstCellHeader(boolean renderRowFirstCellHeader)
      Setter for render first row column as header indicator
      Specified by:
      setRenderRowFirstCellHeader in interface GridLayoutManager
      Parameters:
      renderRowFirstCellHeader -

    • isRenderFirstRowHeader

      public boolean isRenderFirstRowHeader()
      Indicates whether the first row of items rendered should all be rendered as table header (th) cells

      Generally when using a grid layout all the cells will be tds or alternating th/td (with the label in the th cell). However in some cases it might be desired to display the labels in one row as table header cells (th) followed by a row with the corresponding fields in td cells. When this is enabled this type of layout is possible

      Specified by:
      isRenderFirstRowHeader in interface GridLayoutManager
      Returns:
      true if first row should be rendered as header cells

    • setRenderFirstRowHeader

      public void setRenderFirstRowHeader(boolean renderFirstRowHeader)
      Setter for the first row as header indicator
      Specified by:
      setRenderFirstRowHeader in interface GridLayoutManager
      Parameters:
      renderFirstRowHeader -

    • isRenderAlternatingHeaderColumns

      public boolean isRenderAlternatingHeaderColumns()
      Indicates whether header columns (th for tables) should be rendered for every other item (alternating)

      If true the first cell of each row will be rendered as an header, with every other cell in the row as a header

      Specified by:
      isRenderAlternatingHeaderColumns in interface GridLayoutManager
      Returns:
      true if alternating headers should be rendered, false if not

    • setRenderAlternatingHeaderColumns

      public void setRenderAlternatingHeaderColumns(boolean renderAlternatingHeaderColumns)
      Setter for the render alternating header columns indicator
      Specified by:
      setRenderAlternatingHeaderColumns in interface GridLayoutManager
      Parameters:
      renderAlternatingHeaderColumns -

    • getRowCssClasses

      public List<String> getRowCssClasses()
      List of styles for each row.

      Each entry in the list gives the style for the row with the same index. This style will be added to the <tr> tag when the table rows are rendered in the grid.tag. This is used to store the styles for newly added lines and other special cases like the add item row.

      Specified by:
      getRowCssClasses in interface GridLayoutManager
      Returns:
      list of styles for the rows

    • setRowCssClasses

      public void setRowCssClasses(List<String> rowCssClasses)
      Specified by:
      setRowCssClasses in interface GridLayoutManager
      See Also:

    • getRowDataAttributes

      public List<String> getRowDataAttributes()
      List of data attributes for each row.

      Each entry in the list gives the data attributes for the row with the same index. These data attributes will be added to the <tr> tag when the table rows are rendered in the grid.tag. This is used to store the data attributes for newly added lines and other special cases like the add item row.

      Specified by:
      getRowDataAttributes in interface GridLayoutManager
      Returns:
      list of styles for the rows

    • setRowDataAttributes

      public void setRowDataAttributes(List<String> rowDataAttributes)
      Specified by:
      setRowDataAttributes in interface GridLayoutManager
      See Also: