QGridLayoutEngine Class Reference

#include <qgridlayoutengine_p.h>

Public Functions
void	addItem (QGridLayoutItem *item)
Qt::Alignment	alignment (QGraphicsLayoutItem *layoutItem) const
QRectF	cellRect (const QLayoutStyleInfo &styleInfo, const QRectF &contentsGeometry, int row, int column, int rowSpan, int columnSpan) const
int	columnCount (Qt::Orientation orientation) const
int	columnCount () const
Qt::Orientation	constraintOrientation () const
QSizePolicy::ControlTypes	controlTypes (LayoutSide side) const
void	dump (int indent=0) const
QSizeF	dynamicallyConstrainedSizeHint (Qt::SizeHint which, const QSizeF &constraint) const
Qt::Alignment	effectiveAlignment (const QGridLayoutItem *layoutItem) const
int	effectiveFirstRow (Qt::Orientation orientation=Qt::Vertical) const
int	effectiveLastRow (Qt::Orientation orientation=Qt::Vertical) const
bool	ensureDynamicConstraint () const
QGridLayoutItem *	findLayoutItem (QGraphicsLayoutItem *layoutItem) const
bool	hasDynamicConstraint () const
int	indexOf (QGraphicsLayoutItem *item) const
void	insertItem (QGridLayoutItem *item, int index)
	The index is only used by QGraphicsLinearLayout to ensure that itemAt() reflects the order of visual arrangement. More...
void	insertRow (int row, Qt::Orientation orientation=Qt::Vertical)
void	invalidate ()
QGridLayoutItem *	itemAt (int index) const
QGridLayoutItem *	itemAt (int row, int column, Qt::Orientation orientation=Qt::Vertical) const
int	itemCount () const
	QGridLayoutEngine ()
void	removeItem (QGridLayoutItem *item)
void	removeRows (int row, int count, Qt::Orientation orientation)
Qt::Alignment	rowAlignment (int row, Qt::Orientation orientation) const
int	rowCount (Qt::Orientation orientation) const
int	rowCount () const
qreal	rowSizeHint (Qt::SizeHint which, int row, Qt::Orientation orientation=Qt::Vertical) const
qreal	rowSpacing (int row, Qt::Orientation orientation=Qt::Vertical) const
int	rowStretchFactor (int row, Qt::Orientation orientation=Qt::Vertical) const
void	setAlignment (QGraphicsLayoutItem *layoutItem, Qt::Alignment alignment)
void	setGeometries (const QLayoutStyleInfo &styleInfo, const QRectF &contentsGeometry)
void	setRowAlignment (int row, Qt::Alignment alignment, Qt::Orientation orientation)
void	setRowSizeHint (Qt::SizeHint which, int row, qreal size, Qt::Orientation orientation=Qt::Vertical)
void	setRowSpacing (int row, qreal spacing, Qt::Orientation orientation=Qt::Vertical)
void	setRowStretchFactor (int row, int stretch, Qt::Orientation orientation=Qt::Vertical)
void	setSpacing (qreal spacing, Qt::Orientations orientations)
void	setStretchFactor (QGraphicsLayoutItem *layoutItem, int stretch, Qt::Orientation orientation)
void	setVisualDirection (Qt::LayoutDirection direction)
QSizeF	sizeHint (const QLayoutStyleInfo &styleInfo, Qt::SizeHint which, const QSizeF &constraint) const
qreal	spacing (const QLayoutStyleInfo &styleInfo, Qt::Orientation orientation) const
int	stretchFactor (QGraphicsLayoutItem *layoutItem, Qt::Orientation orientation) const
void	transpose ()
Qt::LayoutDirection	visualDirection () const
	~QGridLayoutEngine ()

Private Functions
void	ensureColumnAndRowData (QGridLayoutRowData *rowData, QGridLayoutBox *totalBox, const QLayoutStyleInfo &styleInfo, qreal *colPositions, qreal *colSizes, Qt::Orientation orientation) const
void	ensureEffectiveFirstAndLastRows () const
void	ensureGeometries (const QLayoutStyleInfo &styleInfo, const QSizeF &size) const
void	fillRowData (QGridLayoutRowData *rowData, const QLayoutStyleInfo &styleInfo, qreal *colPositions, qreal *colSizes, Qt::Orientation orientation=Qt::Vertical) const
void	insertOrRemoveRows (int row, int delta, Qt::Orientation orientation=Qt::Vertical)
int	internalGridColumnCount () const
int	internalGridRowCount () const
void	maybeExpandGrid (int row, int column, Qt::Orientation orientation=Qt::Vertical)
void	regenerateGrid ()
void	setItemAt (int row, int column, QGridLayoutItem *item)

Static Private Functions
static int	grossRoundUp (int n)

Properties
Qt::LayoutDirection	m_visualDirection
quint8	q_cachedConstraintOrientation: 3
QLayoutStyleInfo	q_cachedDataForStyleInfo
int	q_cachedEffectiveFirstRows [NOrientations]
int	q_cachedEffectiveLastRows [NOrientations]
QSizeF	q_cachedSize
QGridLayoutRowData	q_columnData
QLayoutParameter< qreal >	q_defaultSpacings [NOrientations]
QVector< qreal >	q_descents
QVector< QGridLayoutItem * >	q_grid
QVector< qreal >	q_heights
QGridLayoutRowInfo	q_infos [NOrientations]
QList< QGridLayoutItem * >	q_items
QGridLayoutRowData	q_rowData
QGridLayoutBox	q_totalBoxes [NOrientations]
QVector< qreal >	q_widths
QVector< qreal >	q_xx
QVector< qreal >	q_yy

Friends
class	QGridLayoutItem

Detailed Description

Definition at line 331 of file qgridlayoutengine_p.h.

Constructors and Destructors

QGridLayoutEngine()

QGridLayoutEngine::QGridLayoutEngine

(

)

Definition at line 803 of file qgridlayoutengine.cpp.

{
    m_visualDirection = Qt::LeftToRight;
    invalidate();
}

~QGridLayoutEngine()

QGridLayoutEngine::~QGridLayoutEngine ( )

inline

Definition at line 335 of file qgridlayoutengine_p.h.

{ qDeleteAll(q_items); }

Functions

addItem()

void QGridLayoutEngine::addItem

(

QGridLayoutItem *

item

)

Definition at line 1029 of file qgridlayoutengine.cpp.

{
    insertItem(item, -1);
}

alignment()

Qt::Alignment QGridLayoutEngine::alignment

(

QGraphicsLayoutItem *

layoutItem

)

const

Definition at line 979 of file qgridlayoutengine.cpp.

{
    if (QGridLayoutItem *item = findLayoutItem(layoutItem))
        return item->alignment();
    return 0;
}

cellRect()

QRectF QGridLayoutEngine::cellRect	(	const QLayoutStyleInfo &	styleInfo,
		const QRectF &	contentsGeometry,
		int	row,
		int	column,
		int	rowSpan,
		int	columnSpan
	)		const

Definition at line 1115 of file qgridlayoutengine.cpp.

{
    if (uint(row) >= uint(rowCount()) || uint(column) >= uint(columnCount())
            || rowSpan < 1 || columnSpan < 1)
        return QRectF();

    ensureGeometries(styleInfo, contentsGeometry.size());

    int lastColumn = qMax(column + columnSpan, columnCount()) - 1;
    int lastRow = qMax(row + rowSpan, rowCount()) - 1;

    qreal x = q_xx[column];
    qreal y = q_yy[row];
    qreal width = q_widths[lastColumn];
    qreal height = q_heights[lastRow];

    if (columnSpan != 1)
        width += q_xx[lastColumn] - x;
    if (rowSpan != 1)
        height += q_yy[lastRow] - y;

    return QRectF(contentsGeometry.x() + x, contentsGeometry.y() + y, width, height);
}

columnCount() [1/2]

int QGridLayoutEngine::columnCount

(

Qt::Orientation

orientation

)

const

Definition at line 814 of file qgridlayoutengine.cpp.

Referenced by QGraphicsLinearLayoutPrivate::gridColumn().

{
    return q_infos[orientation == Qt::Horizontal].count;
}

columnCount() [2/2]

int QGridLayoutEngine::columnCount ( ) const

inline

Definition at line 340 of file qgridlayoutengine_p.h.

{ return q_infos[Hor].count; }

constraintOrientation()

Qt::Orientation QGridLayoutEngine::constraintOrientation

(

)

const

Definition at line 1699 of file qgridlayoutengine.cpp.

{
    (void)ensureDynamicConstraint();
    return (Qt::Orientation)q_cachedConstraintOrientation;
}

controlTypes()

QSizePolicy::ControlTypes QGridLayoutEngine::controlTypes

(

LayoutSide

side

)

const

Definition at line 1215 of file qgridlayoutengine.cpp.

{
    Qt::Orientation orientation = (side == Top || side == Bottom) ? Qt::Vertical : Qt::Horizontal;
    int row = (side == Top || side == Left) ? effectiveFirstRow(orientation)
                                            : effectiveLastRow(orientation);
    QSizePolicy::ControlTypes result = 0;

    for (int column = columnCount(orientation) - 1; column >= 0; --column) {
        if (QGridLayoutItem *item = itemAt(row, column, orientation))
            result |= item->controlTypes(side);
    }
    return result;
}

dump()

void QGridLayoutEngine::dump

(

int

indent = 0

)

const

Definition at line 1253 of file qgridlayoutengine.cpp.

{
    qDebug("%*sEngine", indent, "");

    qDebug("%*s Items (%d)", indent, "", q_items.count());
    int i;
    for (i = 0; i < q_items.count(); ++i)
        q_items.at(i)->dump(indent + 2);

    qDebug("%*s Grid (%d x %d)", indent, "", internalGridRowCount(),
           internalGridColumnCount());
    for (int row = 0; row < internalGridRowCount(); ++row) {
        QString message = QLatin1String("[ ");
        for (int column = 0; column < internalGridColumnCount(); ++column) {
            message += QString::number(q_items.indexOf(itemAt(row, column))).rightJustified(3);
            message += QLatin1Char(' ');
        }
        message += QLatin1Char(']');
        qDebug("%*s  %s", indent, "", qPrintable(message));
    }

    if (q_defaultSpacings[Hor].value() >= 0.0 || q_defaultSpacings[Ver].value() >= 0.0)
        qDebug("%*s Default spacings: %g %g", indent, "", q_defaultSpacings[Hor].value(),
               q_defaultSpacings[Ver].value());

    qDebug("%*s Column and row info", indent, "");
    q_infos[Hor].dump(indent + 2);
    q_infos[Ver].dump(indent + 2);

    qDebug("%*s Column and row data", indent, "");
    q_columnData.dump(indent + 2);
    q_rowData.dump(indent + 2);

    qDebug("%*s Geometries output", indent, "");
    QVector<qreal> *cellPos = &q_yy;
    for (int pass = 0; pass < 2; ++pass) {
        QString message;
        for (i = 0; i < cellPos->count(); ++i) {
            message += QLatin1String((message.isEmpty() ? "[" : ", "));
            message += QString::number(cellPos->at(i));
        }
        message += QLatin1Char(']');
        qDebug("%*s %s %s", indent, "", (pass == 0 ? "rows:" : "columns:"), qPrintable(message));
        cellPos = &q_xx;
    }
}

dynamicallyConstrainedSizeHint()

QSizeF QGridLayoutEngine::dynamicallyConstrainedSizeHint	(	Qt::SizeHint	which,
		const QSizeF &	constraint
	)		const

effectiveAlignment()

Qt::Alignment QGridLayoutEngine::effectiveAlignment

(

const QGridLayoutItem *

layoutItem

)

const

Definition at line 986 of file qgridlayoutengine.cpp.

Referenced by QGridLayoutItem::geometryWithin().

{
    Qt::Alignment align = layoutItem->alignment();
    if (!(align & Qt::AlignVertical_Mask)) {
        // no vertical alignment, respect the row alignment
        int y = layoutItem->firstRow();
        align |= (rowAlignment(y, Qt::Vertical) & Qt::AlignVertical_Mask);
    }
    if (!(align & Qt::AlignHorizontal_Mask)) {
        // no horizontal alignment, respect the column alignment
        int x = layoutItem->firstColumn();
        align |= (rowAlignment(x, Qt::Horizontal) & Qt::AlignHorizontal_Mask);
    }
    return align;
}

effectiveFirstRow()

int QGridLayoutEngine::effectiveFirstRow

(

Qt::Orientation

orientation = Qt::Vertical

)

const

Definition at line 839 of file qgridlayoutengine.cpp.

{
    ensureEffectiveFirstAndLastRows();
    return q_cachedEffectiveFirstRows[orientation == Qt::Vertical];
}

effectiveLastRow()

int QGridLayoutEngine::effectiveLastRow

(

Qt::Orientation

orientation = Qt::Vertical

)

const

Definition at line 845 of file qgridlayoutengine.cpp.

{
    ensureEffectiveFirstAndLastRows();
    return q_cachedEffectiveLastRows[orientation == Qt::Vertical];
}

ensureColumnAndRowData()

void QGridLayoutEngine::ensureColumnAndRowData ( QGridLayoutRowData *  rowData, QGridLayoutBox *  totalBox, const QLayoutStyleInfo &  styleInfo, qreal *  colPositions, qreal *  colSizes, Qt::Orientation  orientation  ) const

private

Definition at line 1649 of file qgridlayoutengine.cpp.

{
    rowData->reset(rowCount(orientation));
    fillRowData(rowData, styleInfo, colPositions, colSizes, orientation);
    const QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
    rowData->distributeMultiCells(rowInfo);
    *totalBox = rowData->totalBox(0, rowCount(orientation));
        //We have items whose width depends on their height
}

ensureDynamicConstraint()

bool QGridLayoutEngine::ensureDynamicConstraint

(

)

const

returns false if the layout has contradicting constraints (i.e. some items with a horizontal constraint and other items with a vertical constraint)

Definition at line 1666 of file qgridlayoutengine.cpp.

{
    if (q_cachedConstraintOrientation == UnknownConstraint) {
        for (int i = q_items.count() - 1; i >= 0; --i) {
            QGridLayoutItem *item = q_items.at(i);
            if (item->hasDynamicConstraint()) {
                Qt::Orientation itemConstraintOrientation = item->dynamicConstraintOrientation();
                if (q_cachedConstraintOrientation == UnknownConstraint) {
                    q_cachedConstraintOrientation = itemConstraintOrientation;
                } else if (q_cachedConstraintOrientation != itemConstraintOrientation) {
                    q_cachedConstraintOrientation = UnfeasibleConstraint;
                    qWarning("QGridLayoutEngine: Unfeasible, cannot mix horizontal and"
                             " vertical constraint in the same layout");
                    return false;
                }
            }
        }
        if (q_cachedConstraintOrientation == UnknownConstraint)
            q_cachedConstraintOrientation = NoConstraint;
    }
    return true;
}

ensureEffectiveFirstAndLastRows()

void QGridLayoutEngine::ensureEffectiveFirstAndLastRows ( ) const

private

Definition at line 1624 of file qgridlayoutengine.cpp.

{
    if (q_cachedEffectiveFirstRows[Hor] == -1 && !q_items.isEmpty()) {
        int rowCount = this->rowCount();
        int columnCount = this->columnCount();

        q_cachedEffectiveFirstRows[Ver] = rowCount;
        q_cachedEffectiveFirstRows[Hor] = columnCount;
        q_cachedEffectiveLastRows[Ver] = -1;
        q_cachedEffectiveLastRows[Hor] = -1;

        for (int i = q_items.count() - 1; i >= 0; --i) {
            const QGridLayoutItem *item = q_items.at(i);

            for (int j = 0; j < NOrientations; ++j) {
                Qt::Orientation orientation = (j == Hor) ? Qt::Horizontal : Qt::Vertical;
                if (item->firstRow(orientation) < q_cachedEffectiveFirstRows[j])
                    q_cachedEffectiveFirstRows[j] = item->firstRow(orientation);
                if (item->lastRow(orientation) > q_cachedEffectiveLastRows[j])
                    q_cachedEffectiveLastRows[j] = item->lastRow(orientation);
            }
        }
    }
}

ensureGeometries()

void QGridLayoutEngine::ensureGeometries ( const QLayoutStyleInfo &  styleInfo, const QSizeF &  size  ) const

private

Definition at line 1705 of file qgridlayoutengine.cpp.

{
    if (q_cachedDataForStyleInfo == styleInfo && q_cachedSize == size)
        return;

    q_cachedDataForStyleInfo = styleInfo;
    q_cachedSize = size;

    q_xx.resize(columnCount());
    q_widths.resize(columnCount());
    q_yy.resize(rowCount());
    q_heights.resize(rowCount());
    q_descents.resize(rowCount());

    if (constraintOrientation() != Qt::Horizontal) {
        //We might have items whose width depends on their height
        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
        //Calculate column widths and positions, and put results in q_xx.data() and q_widths.data() so that we can use this information as
        //constraints to find the row heights
        q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
                0, q_totalBoxes[Hor], q_infos[Hor] );
        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], styleInfo, q_xx.data(), q_widths.data(), Qt::Vertical);
        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data()
        q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
                q_descents.data(), q_totalBoxes[Ver], q_infos[Ver]);
    } else {
        //We have items whose height depends on their width
        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data() so that we can use this information as
        //constraints to find the column widths
        q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
                q_descents.data(), q_totalBoxes[Ver], q_infos[Ver]);
        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], styleInfo, q_yy.data(), q_heights.data(), Qt::Horizontal);
        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data()
        q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
                0, q_totalBoxes[Hor], q_infos[Hor]);
    }
}

fillRowData()

void QGridLayoutEngine::fillRowData ( QGridLayoutRowData *  rowData, const QLayoutStyleInfo &  styleInfo, qreal *  colPositions, qreal *  colSizes, Qt::Orientation  orientation = Qt::Vertical  ) const

private

Definition at line 1383 of file qgridlayoutengine.cpp.

{
    const int ButtonMask = QSizePolicy::ButtonBox | QSizePolicy::PushButton;
    const QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
    const QGridLayoutRowInfo &columnInfo = q_infos[orientation == Qt::Horizontal];
    LayoutSide top = (orientation == Qt::Vertical) ? Top : Left;
    LayoutSide bottom = (orientation == Qt::Vertical) ? Bottom : Right;

    QStyle *style = styleInfo.style();
    QStyleOption option;
    option.initFrom(styleInfo.widget());

    const QLayoutParameter<qreal> &defaultSpacing = q_defaultSpacings[orientation == Qt::Vertical];
    qreal innerSpacing = 0.0;
    if (style)
        innerSpacing = (qreal)style->pixelMetric(orientation == Qt::Vertical ? QStyle::PM_LayoutVerticalSpacing
                                                       : QStyle::PM_LayoutHorizontalSpacing,
                           &option, styleInfo.widget());
    if (innerSpacing >= 0.0)
        defaultSpacing.setCachedValue(innerSpacing);

    for (int row = 0; row < rowInfo.count; ++row) {
        bool rowIsEmpty = true;
        bool rowIsIdenticalToPrevious = (row > 0);

        for (int column = 0; column < columnInfo.count; ++column) {
            QGridLayoutItem *item = itemAt(row, column, orientation);

            if (rowIsIdenticalToPrevious && item != itemAt(row - 1, column, orientation))
                rowIsIdenticalToPrevious = false;

            if (item)
                rowIsEmpty = false;
        }

        if ((rowIsEmpty || rowIsIdenticalToPrevious)
                && rowInfo.spacings.value(row).isDefault()
                && rowInfo.stretches.value(row).isDefault()
                && rowInfo.boxes.value(row) == QGridLayoutBox())
            rowData->ignore.setBit(row, true);

        if (rowInfo.spacings.value(row).isUser()) {
            rowData->spacings[row] = rowInfo.spacings.at(row).value();
        } else if (!defaultSpacing.isDefault()) {
            rowData->spacings[row] = defaultSpacing.value();
        }

        rowData->stretches[row] = rowInfo.stretches.value(row).value();
    }

    struct RowAdHocData {
        int q_row;
        unsigned int q_hasButtons : 8;
        unsigned int q_hasNonButtons : 8;

        inline RowAdHocData() : q_row(-1), q_hasButtons(false), q_hasNonButtons(false) {}
        inline void init(int row) {
            this->q_row = row;
            q_hasButtons = false;
            q_hasNonButtons = false;
        }
        inline bool hasOnlyButtons() const { return q_hasButtons && !q_hasNonButtons; }
        inline bool hasOnlyNonButtons() const { return q_hasNonButtons && !q_hasButtons; }
    };
    RowAdHocData lastRowAdHocData;
    RowAdHocData nextToLastRowAdHocData;
    RowAdHocData nextToNextToLastRowAdHocData;

    rowData->hasIgnoreFlag = false;
    for (int row = 0; row < rowInfo.count; ++row) {
        if (rowData->ignore.testBit(row))
            continue;

        QGridLayoutBox &rowBox = rowData->boxes[row];
        if (option.state & QStyle::State_Window) {
            nextToNextToLastRowAdHocData = nextToLastRowAdHocData;
            nextToLastRowAdHocData = lastRowAdHocData;
            lastRowAdHocData.init(row);
        }

        bool userRowStretch = rowInfo.stretches.value(row).isUser();
        int &rowStretch = rowData->stretches[row];

        bool hasIgnoreFlag = true;
        for (int column = 0; column < columnInfo.count; ++column) {
            QGridLayoutItem *item = itemAt(row, column, orientation);
            if (item) {
                int itemRow = item->firstRow(orientation);
                int itemColumn = item->firstColumn(orientation);

                if (itemRow == row && itemColumn == column) {
                    int itemStretch = item->stretchFactor(orientation);
                    if (!(item->sizePolicy(orientation) & QSizePolicy::IgnoreFlag))
                        hasIgnoreFlag = false;
                    int itemRowSpan = item->rowSpan(orientation);

                    int effectiveRowSpan = 1;
                    for (int i = 1; i < itemRowSpan; ++i) {
                        if (!rowData->ignore.testBit(i + itemRow))
                            ++effectiveRowSpan;
                    }

                    QGridLayoutBox *box;
                    if (effectiveRowSpan == 1) {
                        box = &rowBox;
                        if (!userRowStretch && itemStretch != 0)
                            rowStretch = qMax(rowStretch, itemStretch);
                    } else {
                        QGridLayoutMultiCellData &multiCell =
                                rowData->multiCellMap[qMakePair(row, effectiveRowSpan)];
                        box = &multiCell.q_box;
                        multiCell.q_stretch = itemStretch;
                    }
                    // Items with constraints need to be passed the constraint
                    if (colSizes && colPositions && item->hasDynamicConstraint() && orientation == item->dynamicConstraintOrientation()) {
                        /* Get the width of the item by summing up the widths of the columns that it spans.
                         * We need to have already calculated the widths of the columns by calling
                         * q_columns->calculateGeometries() before hand and passing the value in the colSizes
                         * and colPositions parameters.
                         * The variable name is still colSizes even when it actually has the row sizes
                         */
                        qreal length = colSizes[item->lastColumn(orientation)];
                        if (item->columnSpan(orientation) != 1)
                            length += colPositions[item->lastColumn(orientation)] - colPositions[item->firstColumn(orientation)];
                        box->combine(item->box(orientation, length));
                    } else {
                        box->combine(item->box(orientation));
                    }

                    if (effectiveRowSpan == 1) {
                        QSizePolicy::ControlTypes controls = item->controlTypes(top);
                        if (controls & ButtonMask)
                            lastRowAdHocData.q_hasButtons = true;
                        if (controls & ~ButtonMask)
                            lastRowAdHocData.q_hasNonButtons = true;
                    }
                }
            }
        }
        if (row < rowInfo.boxes.count()) {
            QGridLayoutBox rowBoxInfo = rowInfo.boxes.at(row);
            rowBoxInfo.normalize();
            rowBox.q_minimumSize = qMax(rowBox.q_minimumSize, rowBoxInfo.q_minimumSize);
            rowBox.q_maximumSize = qMax(rowBox.q_minimumSize,
                                        (rowBoxInfo.q_maximumSize != FLT_MAX ?
                                        rowBoxInfo.q_maximumSize : rowBox.q_maximumSize));
            rowBox.q_preferredSize = qBound(rowBox.q_minimumSize,
                                            qMax(rowBox.q_preferredSize, rowBoxInfo.q_preferredSize),
                                            rowBox.q_maximumSize);
        }
        if (hasIgnoreFlag)
            rowData->hasIgnoreFlag = true;
    }

    /*
        Heuristic: Detect button boxes that don't use QSizePolicy::ButtonBox.
        This is somewhat ad hoc but it usually does the trick.
    */
    bool lastRowIsButtonBox = (lastRowAdHocData.hasOnlyButtons()
                               && nextToLastRowAdHocData.hasOnlyNonButtons());
    bool lastTwoRowsIsButtonBox = (lastRowAdHocData.hasOnlyButtons()
                                   && nextToLastRowAdHocData.hasOnlyButtons()
                                   && nextToNextToLastRowAdHocData.hasOnlyNonButtons()
                                   && orientation == Qt::Vertical);

    if (defaultSpacing.isDefault()) {
        int prevRow = -1;
        for (int row = 0; row < rowInfo.count; ++row) {
            if (rowData->ignore.testBit(row))
                continue;

            if (prevRow != -1 && !rowInfo.spacings.value(prevRow).isUser()) {
                qreal &rowSpacing = rowData->spacings[prevRow];
                for (int column = 0; column < columnInfo.count; ++column) {
                    QGridLayoutItem *item1 = itemAt(prevRow, column, orientation);
                    QGridLayoutItem *item2 = itemAt(row, column, orientation);

                    if (item1 && item2 && item1 != item2) {
                        QSizePolicy::ControlTypes controls1 = item1->controlTypes(bottom);
                        QSizePolicy::ControlTypes controls2 = item2->controlTypes(top);

                        if (controls2 & QSizePolicy::PushButton) {
                            if ((row == nextToLastRowAdHocData.q_row && lastTwoRowsIsButtonBox)
                                    || (row == lastRowAdHocData.q_row && lastRowIsButtonBox)) {
                                controls2 &= ~QSizePolicy::PushButton;
                                controls2 |= QSizePolicy::ButtonBox;
                            }
                        }

                        qreal spacing = style->combinedLayoutSpacing(controls1, controls2,
                                                                     orientation, &option,
                                                                     styleInfo.widget());
                        if (orientation == Qt::Horizontal) {
                            qreal width1 = rowData->boxes.at(prevRow).q_minimumSize;
                            qreal width2 = rowData->boxes.at(row).q_minimumSize;
                            QRectF rect1 = item1->geometryWithin(0.0, 0.0, width1, FLT_MAX, -1.0);
                            QRectF rect2 = item2->geometryWithin(0.0, 0.0, width2, FLT_MAX, -1.0);
                            spacing -= (width1 - (rect1.x() + rect1.width())) + rect2.x();
                        } else {
                            const QGridLayoutBox &box1 = rowData->boxes.at(prevRow);
                            const QGridLayoutBox &box2 = rowData->boxes.at(row);
                            qreal height1 = box1.q_minimumSize;
                            qreal height2 = box2.q_minimumSize;
                            qreal rowDescent1 = fixedDescent(box1.q_minimumDescent,
                                                             box1.q_minimumAscent, height1);
                            qreal rowDescent2 = fixedDescent(box2.q_minimumDescent,
                                                             box2.q_minimumAscent, height2);
                            QRectF rect1 = item1->geometryWithin(0.0, 0.0, FLT_MAX, height1,
                                                                 rowDescent1);
                            QRectF rect2 = item2->geometryWithin(0.0, 0.0, FLT_MAX, height2,
                                                                 rowDescent2);
                            spacing -= (height1 - (rect1.y() + rect1.height())) + rect2.y();
                        }
                        rowSpacing = qMax(spacing, rowSpacing);
                    }
                }
            }
            prevRow = row;
        }
    } else if (lastRowIsButtonBox || lastTwoRowsIsButtonBox) {
        /*
            Even for styles that define a uniform spacing, we cheat a
            bit and use the window margin as the spacing. This
            significantly improves the look of dialogs.
        */
        int prevRow = lastRowIsButtonBox ? nextToLastRowAdHocData.q_row
                                         : nextToNextToLastRowAdHocData.q_row;
        if (!defaultSpacing.isUser() && !rowInfo.spacings.value(prevRow).isUser()) {
            qreal windowMargin = style->pixelMetric(orientation == Qt::Vertical
                                                          ? QStyle::PM_LayoutBottomMargin
                                                          : QStyle::PM_LayoutRightMargin,
                                                  &option, styleInfo.widget());

            qreal &rowSpacing = rowData->spacings[prevRow];
            rowSpacing = qMax(windowMargin, rowSpacing);
        }
    }
}

findLayoutItem()

QGridLayoutItem * QGridLayoutEngine::findLayoutItem

(

QGraphicsLayoutItem *

layoutItem

)

const

Definition at line 1050 of file qgridlayoutengine.cpp.

{
    for (int i = q_items.count() - 1; i >= 0; --i) {
        QGridLayoutItem *item = q_items.at(i);
        if (item->layoutItem() == layoutItem)
            return item;
    }
    return 0;
}

grossRoundUp()

static int QGridLayoutEngine::grossRoundUp ( int  n )

inlinestaticprivate

Definition at line 408 of file qgridlayoutengine_p.h.

{ return ((n + 2) | 0x3) - 2; }

hasDynamicConstraint()

bool QGridLayoutEngine::hasDynamicConstraint

(

)

const

Definition at line 1689 of file qgridlayoutengine.cpp.

{
    if (!ensureDynamicConstraint())
        return false;
    return q_cachedConstraintOrientation != NoConstraint;
}

indexOf()

int QGridLayoutEngine::indexOf

(

QGraphicsLayoutItem *

item

)

const

Definition at line 830 of file qgridlayoutengine.cpp.

{
    for (int i = 0; i < q_items.size(); ++i) {
        if (item == q_items.at(i)->layoutItem())
            return i;
    }
    return -1;
}

insertItem()

void QGridLayoutEngine::insertItem	(	QGridLayoutItem *	item,
		int	index
	)

The index is only used by QGraphicsLinearLayout to ensure that itemAt() reflects the order of visual arrangement.

Warning

This function is not part of the public interface. Strictly speaking it does not have to, but most people expect it to. (And if it didn't we would have to add itemArrangedAt(int index) or something..)

Definition at line 1011 of file qgridlayoutengine.cpp.

Referenced by QGridLayoutItem::QGridLayoutItem().

{
    maybeExpandGrid(item->lastRow(), item->lastColumn());

    if (index == -1)
        q_items.append(item);
    else
        q_items.insert(index, item);

    for (int i = item->firstRow(); i <= item->lastRow(); ++i) {
        for (int j = item->firstColumn(); j <= item->lastColumn(); ++j) {
            if (itemAt(i, j))
                qWarning("QGridLayoutEngine::addItem: Cell (%d, %d) already taken", i, j);
            setItemAt(i, j, item);
        }
    }
}

insertOrRemoveRows()

void QGridLayoutEngine::insertOrRemoveRows ( int  row, int  delta, Qt::Orientation  orientation = Qt::Vertical  )

private

Definition at line 1361 of file qgridlayoutengine.cpp.

{
    int oldRowCount = rowCount(orientation);
    Q_ASSERT(uint(row) <= uint(oldRowCount));

    invalidate();

    // appending rows (or columns) is easy
    if (row == oldRowCount && delta > 0) {
        maybeExpandGrid(oldRowCount + delta - 1, -1, orientation);
        return;
    }

    q_infos[orientation == Qt::Vertical].insertOrRemoveRows(row, delta);

    for (int i = q_items.count() - 1; i >= 0; --i)
        q_items.at(i)->insertOrRemoveRows(row, delta, orientation);

    q_grid.resize(internalGridRowCount() * internalGridColumnCount());
    regenerateGrid();
}

insertRow()

void QGridLayoutEngine::insertRow ( int  row, Qt::Orientation  orientation = Qt::Vertical  )

inline

Definition at line 380 of file qgridlayoutengine_p.h.

        { insertOrRemoveRows(row, +1, orientation); }

internalGridColumnCount()

int QGridLayoutEngine::internalGridColumnCount ( ) const

inlineprivate

Definition at line 413 of file qgridlayoutengine_p.h.

{ return grossRoundUp(columnCount()); }

internalGridRowCount()

int QGridLayoutEngine::internalGridRowCount ( ) const

inlineprivate

Definition at line 412 of file qgridlayoutengine_p.h.

{ return grossRoundUp(rowCount()); }

invalidate()

void QGridLayoutEngine::invalidate

(

)

Definition at line 1069 of file qgridlayoutengine.cpp.

{
    q_cachedEffectiveFirstRows[Hor] = -1;
    q_cachedEffectiveFirstRows[Ver] = -1;
    q_cachedEffectiveLastRows[Hor] = -1;
    q_cachedEffectiveLastRows[Ver] = -1;
    q_cachedDataForStyleInfo.invalidate();
    q_cachedSize = QSizeF();
    q_cachedConstraintOrientation = UnknownConstraint;
}

itemAt() [1/2]

QGridLayoutItem * QGridLayoutEngine::itemAt

(

int

index

)

const

Definition at line 824 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(index >= 0 && index < itemCount());
    return q_items.at(index);
}

itemAt() [2/2]

QGridLayoutItem * QGridLayoutEngine::itemAt	(	int	row,
		int	column,
		Qt::Orientation	orientation = Qt::Vertical
	)		const

Definition at line 1060 of file qgridlayoutengine.cpp.

{
    if (orientation == Qt::Horizontal)
        qSwap(row, column);
    if (uint(row) >= uint(rowCount()) || uint(column) >= uint(columnCount()))
        return 0;
    return q_grid.at((row * internalGridColumnCount()) + column);
}

itemCount()

int QGridLayoutEngine::itemCount

(

)

const

Definition at line 819 of file qgridlayoutengine.cpp.

{
    return q_items.count();
}

maybeExpandGrid()

void QGridLayoutEngine::maybeExpandGrid ( int  row, int  column, Qt::Orientation  orientation = Qt::Vertical  )

private

Definition at line 1301 of file qgridlayoutengine.cpp.

{
    invalidate();   // ### move out of here?

    if (orientation == Qt::Horizontal)
        qSwap(row, column);

    if (row < rowCount() && column < columnCount())
        return;

    int oldGridRowCount = internalGridRowCount();
    int oldGridColumnCount = internalGridColumnCount();

    q_infos[Ver].count = qMax(row + 1, rowCount());
    q_infos[Hor].count = qMax(column + 1, columnCount());

    int newGridRowCount = internalGridRowCount();
    int newGridColumnCount = internalGridColumnCount();

    int newGridSize = newGridRowCount * newGridColumnCount;
    if (newGridSize != q_grid.count()) {
        q_grid.resize(newGridSize);

        if (newGridColumnCount != oldGridColumnCount) {
            for (int i = oldGridRowCount - 1; i >= 1; --i) {
                for (int j = oldGridColumnCount - 1; j >= 0; --j) {
                    int oldIndex = (i * oldGridColumnCount) + j;
                    int newIndex = (i * newGridColumnCount) + j;

                    Q_ASSERT(newIndex > oldIndex);
                    q_grid[newIndex] = q_grid[oldIndex];
                    q_grid[oldIndex] = 0;
                }
            }
        }
    }
}

regenerateGrid()

void QGridLayoutEngine::regenerateGrid ( )

private

Definition at line 1339 of file qgridlayoutengine.cpp.

{
    q_grid.fill(0);

    for (int i = q_items.count() - 1; i >= 0; --i) {
        QGridLayoutItem *item = q_items.at(i);

        for (int j = item->firstRow(); j <= item->lastRow(); ++j) {
            for (int k = item->firstColumn(); k <= item->lastColumn(); ++k) {
                setItemAt(j, k, item);
            }
        }
    }
}

removeItem()

void QGridLayoutEngine::removeItem

(

QGridLayoutItem *

item

)

Definition at line 1034 of file qgridlayoutengine.cpp.

Referenced by QGraphicsLinearLayoutPrivate::removeGridItem().

{
    Q_ASSERT(q_items.contains(item));

    invalidate();

    for (int i = item->firstRow(); i <= item->lastRow(); ++i) {
        for (int j = item->firstColumn(); j <= item->lastColumn(); ++j) {
            if (itemAt(i, j) == item)
                setItemAt(i, j, 0);
        }
    }

    q_items.removeAll(item);
}

removeRows()

void QGridLayoutEngine::removeRows ( int  row, int  count, Qt::Orientation  orientation  )

inline

Definition at line 382 of file qgridlayoutengine_p.h.

Referenced by QGraphicsLinearLayoutPrivate::removeGridItem().

        { insertOrRemoveRows(row, -count, orientation); }

rowAlignment()

Qt::Alignment QGridLayoutEngine::rowAlignment	(	int	row,
		Qt::Orientation	orientation
	)		const

Definition at line 966 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(row >= 0);
    return q_infos[orientation == Qt::Vertical].alignments.value(row);
}

rowCount() [1/2]

int QGridLayoutEngine::rowCount

(

Qt::Orientation

orientation

)

const

Definition at line 809 of file qgridlayoutengine.cpp.

Referenced by QGraphicsLinearLayoutPrivate::fixIndex(), and QGraphicsLinearLayoutPrivate::gridRow().

{
    return q_infos[orientation == Qt::Vertical].count;
}

rowCount() [2/2]

int QGridLayoutEngine::rowCount ( ) const

inline

Definition at line 339 of file qgridlayoutengine_p.h.

{ return q_infos[Ver].count; }

rowSizeHint()

qreal QGridLayoutEngine::rowSizeHint	(	Qt::SizeHint	which,
		int	row,
		Qt::Orientation	orientation = Qt::Vertical
	)		const

Definition at line 948 of file qgridlayoutengine.cpp.

{
    return q_infos[orientation == Qt::Vertical].boxes.value(row).q_sizes(which);
}

rowSpacing()

qreal QGridLayoutEngine::rowSpacing	(	int	row,
		Qt::Orientation	orientation = Qt::Vertical
	)		const

Definition at line 889 of file qgridlayoutengine.cpp.

{
    QLayoutParameter<qreal> spacing = q_infos[orientation == Qt::Vertical].spacings.value(row);
    if (!spacing.isDefault())
        return spacing.value();
    return q_defaultSpacings[orientation == Qt::Vertical].value();
}

rowStretchFactor()

int QGridLayoutEngine::rowStretchFactor	(	int	row,
		Qt::Orientation	orientation = Qt::Vertical
	)		const

Definition at line 910 of file qgridlayoutengine.cpp.

{
    QStretchParameter stretch = q_infos[orientation == Qt::Vertical].stretches.value(row);
    if (!stretch.isDefault())
        return stretch.value();
    return 0;
}

setAlignment()

void QGridLayoutEngine::setAlignment	(	QGraphicsLayoutItem *	layoutItem,
		Qt::Alignment	alignment
	)

Definition at line 972 of file qgridlayoutengine.cpp.

{
    if (QGridLayoutItem *item = findLayoutItem(layoutItem))
        item->setAlignment(alignment);
    invalidate();
}

setGeometries()

void QGridLayoutEngine::setGeometries	(	const QLayoutStyleInfo &	styleInfo,
		const QRectF &	contentsGeometry
	)

Definition at line 1086 of file qgridlayoutengine.cpp.

{
    if (rowCount() < 1 || columnCount() < 1)
        return;

    ensureGeometries(styleInfo, contentsGeometry.size());

    for (int i = q_items.count() - 1; i >= 0; --i) {
        QGridLayoutItem *item = q_items.at(i);

        qreal x = q_xx[item->firstColumn()];
        qreal y = q_yy[item->firstRow()];
        qreal width = q_widths[item->lastColumn()];
        qreal height = q_heights[item->lastRow()];

        if (item->columnSpan() != 1)
            width += q_xx[item->lastColumn()] - x;
        if (item->rowSpan() != 1)
            height += q_yy[item->lastRow()] - y;

        QRectF geom = item->geometryWithin(contentsGeometry.x() + x, contentsGeometry.y() + y,
                                               width, height, q_descents[item->lastRow()]);
        visualRect(&geom, visualDirection(), contentsGeometry);
        item->setGeometry(geom);
    }
}

setItemAt()

void QGridLayoutEngine::setItemAt ( int  row, int  column, QGridLayoutItem *  item  )

private

Definition at line 1354 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(row >= 0 && row < rowCount());
    Q_ASSERT(column >= 0 && column < columnCount());
    q_grid[(row * internalGridColumnCount()) + column] = item;
}

setRowAlignment()

void QGridLayoutEngine::setRowAlignment	(	int	row,
		Qt::Alignment	alignment,
		Qt::Orientation	orientation
	)

Definition at line 953 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(row >= 0);

    maybeExpandGrid(row, -1, orientation);

    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
    if (row >= rowInfo.alignments.count())
        rowInfo.alignments.resize(row + 1);
    rowInfo.alignments[row] = alignment;
}

setRowSizeHint()

void QGridLayoutEngine::setRowSizeHint	(	Qt::SizeHint	which,
		int	row,
		qreal	size,
		Qt::Orientation	orientation = Qt::Vertical
	)

Definition at line 934 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(row >= 0);
    Q_ASSERT(size >= 0.0);

    maybeExpandGrid(row, -1, orientation);

    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
    if (row >= rowInfo.boxes.count())
        rowInfo.boxes.resize(row + 1);
    rowInfo.boxes[row].q_sizes(which) = size;
}

setRowSpacing()

void QGridLayoutEngine::setRowSpacing	(	int	row,
		qreal	spacing,
		Qt::Orientation	orientation = Qt::Vertical
	)

Definition at line 875 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(row >= 0);

    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
    if (row >= rowInfo.spacings.count())
        rowInfo.spacings.resize(row + 1);
    if (spacing >= 0)
        rowInfo.spacings[row].setUserValue(spacing);
    else
        rowInfo.spacings[row] = QLayoutParameter<qreal>();
    invalidate();
}

setRowStretchFactor()

void QGridLayoutEngine::setRowStretchFactor	(	int	row,
		int	stretch,
		Qt::Orientation	orientation = Qt::Vertical
	)

Definition at line 897 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(row >= 0);
    Q_ASSERT(stretch >= 0);

    maybeExpandGrid(row, -1, orientation);

    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
    if (row >= rowInfo.stretches.count())
        rowInfo.stretches.resize(row + 1);
    rowInfo.stretches[row].setUserValue(stretch);
}

setSpacing()

void QGridLayoutEngine::setSpacing	(	qreal	spacing,
		Qt::Orientations	orientations
	)

Definition at line 851 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(spacing >= 0.0);
    if (orientations & Qt::Horizontal)
        q_defaultSpacings[Hor].setUserValue(spacing);
    if (orientations & Qt::Vertical)
        q_defaultSpacings[Ver].setUserValue(spacing);

    invalidate();
}

setStretchFactor()

void QGridLayoutEngine::setStretchFactor	(	QGraphicsLayoutItem *	layoutItem,
		int	stretch,
		Qt::Orientation	orientation
	)

Definition at line 918 of file qgridlayoutengine.cpp.

{
    Q_ASSERT(stretch >= 0);

    if (QGridLayoutItem *item = findLayoutItem(layoutItem))
        item->setStretchFactor(stretch, orientation);
}

setVisualDirection()

void QGridLayoutEngine::setVisualDirection

(

Qt::LayoutDirection

direction

)

Definition at line 1242 of file qgridlayoutengine.cpp.

{
    m_visualDirection = direction;
}

sizeHint()

QSizeF QGridLayoutEngine::sizeHint	(	const QLayoutStyleInfo &	styleInfo,
		Qt::SizeHint	which,
		const QSizeF &	constraint
	)		const

Definition at line 1141 of file qgridlayoutengine.cpp.

{
    QGridLayoutBox sizehint_totalBoxes[NOrientations];

    bool sizeHintCalculated = false;

    if (hasDynamicConstraint() && rowCount() > 0 && columnCount() > 0) {
        if (constraintOrientation() == Qt::Vertical) {
            //We have items whose height depends on their width
            if (constraint.width() >= 0) {
                if (q_cachedDataForStyleInfo != styleInfo)
                    ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
                else
                    sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
                QVector<qreal> sizehint_xx;
                QVector<qreal> sizehint_widths;

                sizehint_xx.resize(columnCount());
                sizehint_widths.resize(columnCount());
                qreal width = constraint.width();
                //Calculate column widths and positions, and put results in q_xx.data() and q_widths.data() so that we can use this information as
                //constraints to find the row heights
                q_columnData.calculateGeometries(0, columnCount(), width, sizehint_xx.data(), sizehint_widths.data(),
                        0, sizehint_totalBoxes[Hor], q_infos[Hor]);
                ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, sizehint_xx.data(), sizehint_widths.data(), Qt::Vertical);
                sizeHintCalculated = true;
            }
        } else {
            if (constraint.height() >= 0) {
                //We have items whose width depends on their height
                ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
                QVector<qreal> sizehint_yy;
                QVector<qreal> sizehint_heights;

                sizehint_yy.resize(rowCount());
                sizehint_heights.resize(rowCount());
                qreal height = constraint.height();
                //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data() so that we can use this information as
                //constraints to find the column widths
                q_rowData.calculateGeometries(0, rowCount(), height, sizehint_yy.data(), sizehint_heights.data(),
                        0, sizehint_totalBoxes[Ver], q_infos[Ver]);
                ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, sizehint_yy.data(), sizehint_heights.data(), Qt::Horizontal);
                sizeHintCalculated = true;
            }
        }
    }

    if (!sizeHintCalculated) {
        //No items with height for width, so it doesn't matter which order we do these in
        if (q_cachedDataForStyleInfo != styleInfo) {
            ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
            ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
        } else {
            sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
            sizehint_totalBoxes[Ver] = q_totalBoxes[Ver];
        }
    }

    switch (which) {
    case Qt::MinimumSize:
        return QSizeF(sizehint_totalBoxes[Hor].q_minimumSize, sizehint_totalBoxes[Ver].q_minimumSize);
    case Qt::PreferredSize:
        return QSizeF(sizehint_totalBoxes[Hor].q_preferredSize, sizehint_totalBoxes[Ver].q_preferredSize);
    case Qt::MaximumSize:
        return QSizeF(sizehint_totalBoxes[Hor].q_maximumSize, sizehint_totalBoxes[Ver].q_maximumSize);
    case Qt::MinimumDescent:
        return QSizeF(-1.0, sizehint_totalBoxes[Hor].q_minimumDescent);    // ### doesn't work
    default:
        break;
    }
    return QSizeF();
}

spacing()

qreal QGridLayoutEngine::spacing	(	const QLayoutStyleInfo &	styleInfo,
		Qt::Orientation	orientation
	)		const

Definition at line 862 of file qgridlayoutengine.cpp.

{
    if (q_defaultSpacings[orientation == Qt::Vertical].isDefault()) {
        QStyle *style = styleInfo.style();
        QStyleOption option;
        option.initFrom(styleInfo.widget());
        qreal defaultSpacing = (qreal)style->pixelMetric(orientation == Qt::Vertical ? QStyle::PM_LayoutVerticalSpacing
                                               : QStyle::PM_LayoutHorizontalSpacing, &option, styleInfo.widget());
        q_defaultSpacings[orientation == Qt::Vertical].setCachedValue(defaultSpacing);
    }
    return q_defaultSpacings[orientation == Qt::Vertical].value();
}

stretchFactor()

int QGridLayoutEngine::stretchFactor	(	QGraphicsLayoutItem *	layoutItem,
		Qt::Orientation	orientation
	)		const

Definition at line 927 of file qgridlayoutengine.cpp.

{
    if (QGridLayoutItem *item = findLayoutItem(layoutItem))
        return item->stretchFactor(orientation);
    return 0;
}

transpose()

void QGridLayoutEngine::transpose

(

)

Definition at line 1229 of file qgridlayoutengine.cpp.

{
    invalidate();

    for (int i = q_items.count() - 1; i >= 0; --i)
        q_items.at(i)->transpose();

    qSwap(q_defaultSpacings[Hor], q_defaultSpacings[Ver]);
    qSwap(q_infos[Hor], q_infos[Ver]);

    regenerateGrid();
}

visualDirection()

Qt::LayoutDirection QGridLayoutEngine::visualDirection

(

)

const

Definition at line 1247 of file qgridlayoutengine.cpp.

{
    return m_visualDirection;
}

Friends and Related Functions

QGridLayoutItem

friend class QGridLayoutItem

friend

Definition at line 453 of file qgridlayoutengine_p.h.

Properties

m_visualDirection

Qt::LayoutDirection QGridLayoutEngine::m_visualDirection

private

Definition at line 432 of file qgridlayoutengine_p.h.

q_cachedConstraintOrientation

quint8 QGridLayoutEngine::q_cachedConstraintOrientation

mutableprivate

Definition at line 437 of file qgridlayoutengine_p.h.

q_cachedDataForStyleInfo

QLayoutStyleInfo QGridLayoutEngine::q_cachedDataForStyleInfo

mutableprivate

Definition at line 440 of file qgridlayoutengine_p.h.

q_cachedEffectiveFirstRows

int QGridLayoutEngine::q_cachedEffectiveFirstRows[NOrientations]

mutableprivate

Definition at line 435 of file qgridlayoutengine_p.h.

q_cachedEffectiveLastRows

int QGridLayoutEngine::q_cachedEffectiveLastRows[NOrientations]

mutableprivate

Definition at line 436 of file qgridlayoutengine_p.h.

q_cachedSize

QSizeF QGridLayoutEngine::q_cachedSize

mutableprivate

Definition at line 446 of file qgridlayoutengine_p.h.

q_columnData

QGridLayoutRowData QGridLayoutEngine::q_columnData

mutableprivate

Definition at line 441 of file qgridlayoutengine_p.h.

q_defaultSpacings

QLayoutParameter<qreal> QGridLayoutEngine::q_defaultSpacings[NOrientations]

private

Definition at line 430 of file qgridlayoutengine_p.h.

q_descents

QVector<qreal> QGridLayoutEngine::q_descents

mutableprivate

Definition at line 451 of file qgridlayoutengine_p.h.

q_grid

QVector<QGridLayoutItem *> QGridLayoutEngine::q_grid

private

Definition at line 428 of file qgridlayoutengine_p.h.

q_heights

QVector<qreal> QGridLayoutEngine::q_heights

mutableprivate

Definition at line 450 of file qgridlayoutengine_p.h.

q_infos

QGridLayoutRowInfo QGridLayoutEngine::q_infos[NOrientations]

private

Definition at line 431 of file qgridlayoutengine_p.h.

q_items

QList<QGridLayoutItem *> QGridLayoutEngine::q_items

private

Definition at line 429 of file qgridlayoutengine_p.h.

q_rowData

QGridLayoutRowData QGridLayoutEngine::q_rowData

mutableprivate

Definition at line 442 of file qgridlayoutengine_p.h.

q_totalBoxes

QGridLayoutBox QGridLayoutEngine::q_totalBoxes[NOrientations]

mutableprivate

Definition at line 443 of file qgridlayoutengine_p.h.

q_widths

QVector<qreal> QGridLayoutEngine::q_widths

mutableprivate

Definition at line 449 of file qgridlayoutengine_p.h.

q_xx

QVector<qreal> QGridLayoutEngine::q_xx

mutableprivate

Definition at line 447 of file qgridlayoutengine_p.h.

q_yy

QVector<qreal> QGridLayoutEngine::q_yy

mutableprivate

Definition at line 448 of file qgridlayoutengine_p.h.

---

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

• /src/gui/graphicsview/qgridlayoutengine_p.h
• /src/gui/graphicsview/qgridlayoutengine.cpp