QCPLayoutGrid Class Reference
Author: Emanuel Eichhammer

· · · ·
Public Types | Public Functions | Protected Functions
QCPLayoutGrid Class Reference

A layout that arranges child elements in a grid. More...

Inheritance diagram for QCPLayoutGrid:

## Public Types
enum | FillOrder
Public Types inherited from QCPLayoutElement
enum | UpdatePhase
enum | SizeConstraintRect

## Public Functions
| QCPLayoutGrid ()
int | rowCount () const
int | columnCount () const
QList< double > | columnStretchFactors () const
QList< double > | rowStretchFactors () const
int | columnSpacing () const
int | rowSpacing () const
int | wrap () const
FillOrder | fillOrder () const
void | setColumnStretchFactor (int column, double factor)
void | setColumnStretchFactors (const QList< double > &factors)
void | setRowStretchFactor (int row, double factor)
void | setRowStretchFactors (const QList< double > &factors)
void | setColumnSpacing (int pixels)
void | setRowSpacing (int pixels)
void | setWrap (int count)
void | setFillOrder (FillOrder order, bool rearrange=true)
virtual void | updateLayout ()
virtual int | elementCount () const
virtual QCPLayoutElement * | elementAt (int index) const
virtual QCPLayoutElement * | takeAt (int index)
virtual bool | take (QCPLayoutElement *element)
virtual QList< QCPLayoutElement * > | elements (bool recursive) const
virtual void | simplify ()
virtual QSize | minimumOuterSizeHint () const
virtual QSize | maximumOuterSizeHint () const
QCPLayoutElement * | element (int row, int column) const
bool | addElement (int row, int column, QCPLayoutElement *element)
bool | addElement (QCPLayoutElement *element)
bool | hasElement (int row, int column)
void | expandTo (int newRowCount, int newColumnCount)
void | insertRow (int newIndex)
void | insertColumn (int newIndex)
int | rowColToIndex (int row, int column) const
void | indexToRowCol (int index, int &row, int &column) const
Public Functions inherited from QCPLayout
| QCPLayout ()
virtual void | update (UpdatePhase phase)
bool | removeAt (int index)
bool | remove (QCPLayoutElement *element)
void | clear ()
Public Functions inherited from QCPLayoutElement
| QCPLayoutElement (QCustomPlot *parentPlot=nullptr)
QCPLayout * | layout () const
QRect | rect () const
QRect | outerRect () const
QMargins | margins () const
QMargins | minimumMargins () const
QCP::MarginSides | autoMargins () const
QSize | minimumSize () const
QSize | maximumSize () const
SizeConstraintRect | sizeConstraintRect () const
QCPMarginGroup * | marginGroup (QCP::MarginSide side) const
QHash< QCP::MarginSide, QCPMarginGroup * > | marginGroups () const
void | setOuterRect (const QRect &rect)
void | setMargins (const QMargins &margins)
void | setMinimumMargins (const QMargins &margins)
void | setAutoMargins (QCP::MarginSides sides)
void | setMinimumSize (const QSize &size)
void | setMinimumSize (int width, int height)
void | setMaximumSize (const QSize &size)
void | setMaximumSize (int width, int height)
void | setSizeConstraintRect (SizeConstraintRect constraintRect)
void | setMarginGroup (QCP::MarginSides sides, QCPMarginGroup *group)
virtual double | selectTest (const QPointF &pos, bool onlySelectable, QVariant *details=nullptr) const
Public Functions inherited from QCPLayerable
| QCPLayerable (QCustomPlot *plot, QString targetLayer=QString(), QCPLayerable *parentLayerable=nullptr)
bool | visible () const
QCustomPlot * | parentPlot () const
QCPLayerable * | parentLayerable () const
QCPLayer * | layer () const
bool | antialiased () const
void | setVisible (bool on)
Q_SLOT bool | setLayer (QCPLayer *layer)
bool | setLayer (const QString &layerName)
void | setAntialiased (bool enabled)
bool | realVisibility () const

## Protected Functions
void | getMinimumRowColSizes (QVector< int > *minColWidths, QVector< int > *minRowHeights) const
void | getMaximumRowColSizes (QVector< int > *maxColWidths, QVector< int > *maxRowHeights) const
Protected Functions inherited from QCPLayout
void | sizeConstraintsChanged () const
void | adoptElement (QCPLayoutElement *el)
void | releaseElement (QCPLayoutElement *el)
QVector< int > | getSectionSizes (QVector< int > maxSizes, QVector< int > minSizes, QVector< double > stretchFactors, int totalSize) const
Protected Functions inherited from QCPLayoutElement
virtual int | calculateAutoMargin (QCP::MarginSide side)
virtual void | layoutChanged ()
virtual void | applyDefaultAntialiasingHint (QCPPainter *painter) const
virtual void | draw (QCPPainter *painter)
virtual void | parentPlotInitialized (QCustomPlot *parentPlot)
Protected Functions inherited from QCPLayerable
virtual QCP::Interaction | selectionCategory () const
virtual QRect | clipRect () const
virtual void | selectEvent (QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
virtual void | deselectEvent (bool *selectionStateChanged)
virtual void | mousePressEvent (QMouseEvent *event, const QVariant &details)
virtual void | mouseMoveEvent (QMouseEvent *event, const QPointF &startPos)
virtual void | mouseReleaseEvent (QMouseEvent *event, const QPointF &startPos)
virtual void | mouseDoubleClickEvent (QMouseEvent *event, const QVariant &details)
virtual void | wheelEvent (QWheelEvent *event)
void | initializeParentPlot (QCustomPlot *parentPlot)
void | setParentLayerable (QCPLayerable *parentLayerable)
bool | moveToLayer (QCPLayer *layer, bool prepend)
void | applyAntialiasingHint (QCPPainter *painter, bool localAntialiased, QCP::AntialiasedElement overrideElement) const

## Additional Inherited Members
Signals inherited from QCPLayerable
void | layerChanged (QCPLayer *newLayer)
Protected Static Functions inherited from QCPLayout
static QSize | getFinalMinimumOuterSize (const QCPLayoutElement *el)
static QSize | getFinalMaximumOuterSize (const QCPLayoutElement *el)

## Detailed Description

A layout that arranges child elements in a grid.

Elements are laid out in a grid with configurable stretch factors (setColumnStretchFactor, setRowStretchFactor) and spacing (setColumnSpacing, setRowSpacing).

Elements can be added to cells via addElement. The grid is expanded if the specified row or column doesn't exist yet. Whether a cell contains a valid layout element can be checked with hasElement, that element can be retrieved with element. If rows and columns that only have empty cells shall be removed, call simplify. Removal of elements is either done by just adding the element to a different layout or by using the QCPLayout interface take or remove.

If you use addElement(QCPLayoutElement*) without explicit parameters for row and column, the grid layout will choose the position according to the current setFillOrder and the wrapping (setWrap).

Row and column insertion can be performed with insertRow and insertColumn.

## Member Enumeration Documentation

## § FillOrder

enum QCPLayoutGrid::FillOrder

Defines in which direction the grid is filled when using addElement(QCPLayoutElement*). The column/row at which wrapping into the next row/column occurs can be specified with setWrap.

See also
  setFillOrder

Enumerator
foRowsFirst | Rows are filled first, and a new element is wrapped to the next column if the row count would exceed setWrap.
foColumnsFirst | Columns are filled first, and a new element is wrapped to the next row if the column count would exceed setWrap.

## Constructor & Destructor Documentation

## § QCPLayoutGrid()

QCPLayoutGrid::QCPLayoutGrid | ( |  | ) |
| explicit

Creates an instance of QCPLayoutGrid and sets default values.

## Member Function Documentation

## § rowCount()

int QCPLayoutGrid::rowCount | ( |  | ) | const
| inline

Returns the number of rows in the layout.

See also
  columnCount

## § columnCount()

int QCPLayoutGrid::columnCount | ( |  | ) | const
| inline

Returns the number of columns in the layout.

See also
  rowCount

## § setColumnStretchFactor()

void QCPLayoutGrid::setColumnStretchFactor | ( | int | column,
|  | double | factor
| ) |  |

Sets the stretch factor of column.

Stretch factors control the relative sizes of rows and columns. Cells will not be resized beyond their minimum and maximum widths/heights, regardless of the stretch factor. (see QCPLayoutElement::setMinimumSize, QCPLayoutElement::setMaximumSize, QCPLayoutElement::setSizeConstraintRect.)

The default stretch factor of newly created rows/columns is 1.

See also
  setColumnStretchFactors, setRowStretchFactor

## § setColumnStretchFactors()

void QCPLayoutGrid::setColumnStretchFactors | ( | const QList< double > & | factors | ) |

Sets the stretch factors of all columns. factors must have the size columnCount.

Stretch factors control the relative sizes of rows and columns. Cells will not be resized beyond their minimum and maximum widths/heights, regardless of the stretch factor. (see QCPLayoutElement::setMinimumSize, QCPLayoutElement::setMaximumSize, QCPLayoutElement::setSizeConstraintRect.)

The default stretch factor of newly created rows/columns is 1.

See also
  setColumnStretchFactor, setRowStretchFactors

## § setRowStretchFactor()

void QCPLayoutGrid::setRowStretchFactor | ( | int | row,
|  | double | factor
| ) |  |

Sets the stretch factor of row.

Stretch factors control the relative sizes of rows and columns. Cells will not be resized beyond their minimum and maximum widths/heights, regardless of the stretch factor. (see QCPLayoutElement::setMinimumSize, QCPLayoutElement::setMaximumSize, QCPLayoutElement::setSizeConstraintRect.)

The default stretch factor of newly created rows/columns is 1.

See also
  setColumnStretchFactors, setRowStretchFactor

## § setRowStretchFactors()

void QCPLayoutGrid::setRowStretchFactors | ( | const QList< double > & | factors | ) |

Sets the stretch factors of all rows. factors must have the size rowCount.

Stretch factors control the relative sizes of rows and columns. Cells will not be resized beyond their minimum and maximum widths/heights, regardless of the stretch factor. (see QCPLayoutElement::setMinimumSize, QCPLayoutElement::setMaximumSize, QCPLayoutElement::setSizeConstraintRect.)

The default stretch factor of newly created rows/columns is 1.

See also
  setRowStretchFactor, setColumnStretchFactors

## § setColumnSpacing()

void QCPLayoutGrid::setColumnSpacing | ( | int | pixels | ) |

Sets the gap that is left blank between columns to pixels.

See also
  setRowSpacing

## § setRowSpacing()

void QCPLayoutGrid::setRowSpacing | ( | int | pixels | ) |

Sets the gap that is left blank between rows to pixels.

See also
  setColumnSpacing

## § setWrap()

void QCPLayoutGrid::setWrap | ( | int | count | ) |

Sets the maximum number of columns or rows that are used, before new elements added with addElement(QCPLayoutElement*) will start to fill the next row or column, respectively. It depends on setFillOrder, whether rows or columns are wrapped.

If count is set to zero, no wrapping will ever occur.

If you wish to re-wrap the elements currently in the layout, call setFillOrder with rearrange set to true (the actual fill order doesn't need to be changed for the rearranging to be done).

Note that the method addElement(int row, int column, QCPLayoutElement *element) with explicitly stated row and column is not subject to wrapping and can place elements even beyond the specified wrapping point.

See also
  setFillOrder

## § setFillOrder()

void QCPLayoutGrid::setFillOrder | ( | FillOrder | order,
|  | bool | rearrange = `true`
| ) |  |

Sets the filling order and wrapping behaviour that is used when adding new elements with the method addElement(QCPLayoutElement*).

The specified order defines whether rows or columns are filled first. Using setWrap, you can control at which row/column count wrapping into the next column/row will occur. If you set it to zero, no wrapping will ever occur. Changing the fill order also changes the meaning of the linear index used e.g. in elementAt and takeAt. The default fill order for QCPLayoutGrid is foColumnsFirst.

If you want to have all current elements arranged in the new order, set rearrange to true. The elements will be rearranged in a way that tries to preserve their linear index. However, empty cells are skipped during build-up of the new cell order, which shifts the succeeding element's index. The rearranging is performed even if the specified order is already the current fill order. Thus this method can be used to re-wrap the current elements.

If rearrange is false, the current element arrangement is not changed, which means the linear indexes change (because the linear index is dependent on the fill order).

Note that the method addElement(int row, int column, QCPLayoutElement *element) with explicitly stated row and column is not subject to wrapping and can place elements even beyond the specified wrapping point.

See also
  setWrap, addElement(QCPLayoutElement*)

## § updateLayout()

void QCPLayoutGrid::updateLayout | ( |  | ) |
| virtual

Subclasses reimplement this method to update the position and sizes of the child elements/cells via calling their QCPLayoutElement::setOuterRect. The default implementation does nothing.

The geometry used as a reference is the inner rect of this layout. Child elements should stay within that rect.

getSectionSizes may help with the reimplementation of this function.

See also
  update

Reimplemented from QCPLayout.

## § elementCount()

virtual int QCPLayoutGrid::elementCount | ( |  | ) | const
| inlinevirtual

Returns the number of elements/cells in the layout.

See also
  elements, elementAt

Implements QCPLayout.

## § elementAt()

QCPLayoutElement * QCPLayoutGrid::elementAt | ( | int | index | ) | const
| virtual

For general information about this virtual method, see the base class implementation.

Note that the association of the linear index to the row/column based cells depends on the current setting of setFillOrder.

See also
  rowColToIndex

Implements QCPLayout.

## § takeAt()

QCPLayoutElement * QCPLayoutGrid::takeAt | ( | int | index | ) |
| virtual

For general information about this virtual method, see the base class implementation.

Note that the association of the linear index to the row/column based cells depends on the current setting of setFillOrder.

See also
  rowColToIndex

Implements QCPLayout.

## § take()

bool QCPLayoutGrid::take | ( | QCPLayoutElement * | element | ) |
| virtual

Removes the specified element from the layout and returns true on success.

If the element isn't in this layout, returns false.

Note that some layouts don't remove the respective cell right away but leave an empty cell after successful removal of the layout element. To collapse empty cells, use simplify.

See also
  takeAt

Implements QCPLayout.

## § elements()

QList< QCPLayoutElement * > QCPLayoutGrid::elements | ( | bool | recursive | ) | const
| virtual

Returns a list of all child elements in this layout element. If recursive is true, all sub-child elements are included in the list, too.

Warning
  There may be `nullptr` entries in the returned list. For example, QCPLayoutGrid may have empty cells which yield `nullptr` at the respective index.

Reimplemented from QCPLayout.

## § simplify()

void QCPLayoutGrid::simplify | ( |  | ) |
| virtual

Simplifies the layout by collapsing rows and columns which only contain empty cells.

Reimplemented from QCPLayout.

## § minimumOuterSizeHint()

QSize QCPLayoutGrid::minimumOuterSizeHint | ( |  | ) | const
| virtual

Returns the suggested minimum size this layout element (the outerRect) may be compressed to, if no manual minimum size is set.

if a minimum size (setMinimumSize) was not set manually, parent layouts use the returned size (usually indirectly through QCPLayout::getFinalMinimumOuterSize) to determine the minimum allowed size of this layout element.

A manual minimum size is considered set if it is non-zero.

The default implementation simply returns the sum of the horizontal margins for the width and the sum of the vertical margins for the height. Reimplementations may use their detailed knowledge about the layout element's content to provide size hints.

Reimplemented from QCPLayoutElement.

## § maximumOuterSizeHint()

QSize QCPLayoutGrid::maximumOuterSizeHint | ( |  | ) | const
| virtual

Returns the suggested maximum size this layout element (the outerRect) may be expanded to, if no manual maximum size is set.

if a maximum size (setMaximumSize) was not set manually, parent layouts use the returned size (usually indirectly through QCPLayout::getFinalMaximumOuterSize) to determine the maximum allowed size of this layout element.

A manual maximum size is considered set if it is smaller than Qt's `QWIDGETSIZE_MAX`.

The default implementation simply returns `QWIDGETSIZE_MAX` for both width and height, implying no suggested maximum size. Reimplementations may use their detailed knowledge about the layout element's content to provide size hints.

Reimplemented from QCPLayoutElement.

## § element()

QCPLayoutElement * QCPLayoutGrid::element | ( | int | row,
|  | int | column
| ) |  | const

Returns the element in the cell in row and column.

Returns `nullptr` if either the row/column is invalid or if the cell is empty. In those cases, a qDebug message is printed. To check whether a cell exists and isn't empty, use hasElement.

See also
  addElement, hasElement

## § addElement() [1/2]

bool QCPLayoutGrid::addElement | ( | int | row,
|  | int | column,
|  | QCPLayoutElement * | element
| ) |  |

This is an overloaded function.

Adds the element to cell with row and column. If element is already in a layout, it is first removed from there. If row or column don't exist yet, the layout is expanded accordingly.

Returns true if the element was added successfully, i.e. if the cell at row and column didn't already have an element.

Use the overload of this method without explicit row/column index to place the element according to the configured fill order and wrapping settings.

See also
  element, hasElement, take, remove

## § addElement() [2/2]

bool QCPLayoutGrid::addElement | ( | QCPLayoutElement * | element | ) |

This is an overloaded function.

Adds the element to the next empty cell according to the current fill order (setFillOrder) and wrapping (setWrap). If element is already in a layout, it is first removed from there. If necessary, the layout is expanded to hold the new element.

Returns true if the element was added successfully.

See also
  setFillOrder, setWrap, element, hasElement, take, remove

## § hasElement()

bool QCPLayoutGrid::hasElement | ( | int | row,
|  | int | column
| ) |  |

Returns whether the cell at row and column exists and contains a valid element, i.e. isn't empty.

See also
  element

## § expandTo()

void QCPLayoutGrid::expandTo | ( | int | newRowCount,
|  | int | newColumnCount
| ) |  |

Expands the layout to have newRowCount rows and newColumnCount columns. So the last valid row index will be newRowCount-1, the last valid column index will be newColumnCount-1.

If the current column/row count is already larger or equal to newColumnCount/newRowCount, this function does nothing in that dimension.

Newly created cells are empty, new rows and columns have the stretch factor 1.

Note that upon a call to addElement, the layout is expanded automatically to contain the specified row and column, using this function.

See also
  simplify

## § insertRow()

void QCPLayoutGrid::insertRow | ( | int | newIndex | ) |

Inserts a new row with empty cells at the row index newIndex. Valid values for newIndex range from 0 (inserts a row at the top) to rowCount (appends a row at the bottom).

See also
  insertColumn

## § insertColumn()

void QCPLayoutGrid::insertColumn | ( | int | newIndex | ) |

Inserts a new column with empty cells at the column index newIndex. Valid values for newIndex range from 0 (inserts a column at the left) to columnCount (appends a column at the right).

See also
  insertRow

## § rowColToIndex()

int QCPLayoutGrid::rowColToIndex | ( | int | row,
|  | int | column
| ) |  | const

Converts the given row and column to the linear index used by some methods of QCPLayoutGrid and QCPLayout.

The way the cells are indexed depends on setFillOrder. If it is foRowsFirst, the indices increase left to right and then top to bottom. If it is foColumnsFirst, the indices increase top to bottom and then left to right.

For the returned index to be valid, row and column must be valid indices themselves, i.e. greater or equal to zero and smaller than the current rowCount/columnCount.

See also
  indexToRowCol

## § indexToRowCol()

void QCPLayoutGrid::indexToRowCol | ( | int | index,
|  | int & | row,
|  | int & | column
| ) |  | const

Converts the linear index to row and column indices and writes the result to row and column.

The way the cells are indexed depends on setFillOrder. If it is foRowsFirst, the indices increase left to right and then top to bottom. If it is foColumnsFirst, the indices increase top to bottom and then left to right.

If there are no cells (i.e. column or row count is zero), sets row and column to -1.

For the retrieved row and column to be valid, the passed index must be valid itself, i.e. greater or equal to zero and smaller than the current elementCount.

See also
  rowColToIndex

## § getMinimumRowColSizes()

void QCPLayoutGrid::getMinimumRowColSizes | ( | QVector< int > * | minColWidths,
|  | QVector< int > * | minRowHeights
| ) |  | const
| protected

Places the minimum column widths and row heights into minColWidths and minRowHeights respectively.

The minimum height of a row is the largest minimum height of any element's outer rect in that row. The minimum width of a column is the largest minimum width of any element's outer rect in that column.

This is a helper function for updateLayout.

See also
  getMaximumRowColSizes

## § getMaximumRowColSizes()

void QCPLayoutGrid::getMaximumRowColSizes | ( | QVector< int > * | maxColWidths,
|  | QVector< int > * | maxRowHeights
| ) |  | const
| protected

Places the maximum column widths and row heights into maxColWidths and maxRowHeights respectively.

The maximum height of a row is the smallest maximum height of any element's outer rect in that row. The maximum width of a column is the smallest maximum width of any element's outer rect in that column.

This is a helper function for updateLayout.

See also
  getMinimumRowColSizes

The documentation for this class was generated from the following files:

- src/layout.h
- src/layout.cpp