QGridLayoutPrivate Class Reference

Inheritance diagram for QGridLayoutPrivate:

Public Functions
void	add (QGridBox *, int row, int col)
void	add (QGridBox *, int row1, int row2, int col1, int col2)
QRect	cellRect (int row, int col) const
int	colSpacing (int c) const
int	colStretch (int c) const
int	count () const
void	deleteAll ()
void	distribute (QRect rect, int hSpacing, int vSpacing)
void	expand (int rows, int cols)
Qt::Orientations	expandingDirections (int hSpacing, int vSpacing) const
void	getItemPosition (int index, int *row, int *column, int *rowSpan, int *columnSpan)
void	getNextPos (int &row, int &col)
bool	hasHeightForWidth (int hSpacing, int vSpacing)
int	heightForWidth (int width, int hSpacing, int vSpacing)
bool	horReversed () const
bool	isDirty () const
QLayoutItem *	itemAt (int index) const
QSize	maximumSize (int hSpacing, int vSpacing) const
int	minimumHeightForWidth (int width, int hSpacing, int vSpacing)
QSize	minimumSize (int hSpacing, int vSpacing) const
int	numCols () const
int	numRows () const
	QGridLayoutPrivate ()
int	rowSpacing (int r) const
int	rowStretch (int r) const
void	setColStretch (int c, int s)
void	setColumnMinimumWidth (int c, int s)
void	setDirty ()
void	setReversed (bool r, bool c)
void	setRowMinimumHeight (int r, int s)
void	setRowStretch (int r, int s)
QSize	sizeHint (int hSpacing, int vSpacing) const
QLayoutItem *	takeAt (int index)
bool	verReversed () const
Public Functions inherited from QLayoutPrivate
void	doResize (const QSize &)
void	getMargin (int *result, int userMargin, QStyle::PixelMetric pm) const
	QLayoutPrivate ()
void	reparentChildWidgets (QWidget *mw)
Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)
void	addConnection (int signal, Connection *c)
void	cleanConnectionLists ()
void	connectNotify (const char *signal)
void	deleteChildren ()
void	disconnectNotify (const char *signal)
bool	isSender (const QObject *receiver, const char *signal) const
bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...
void	moveToThread_helper ()
	QObjectPrivate (int version=QObjectPrivateVersion)
QObjectList	receiverList (const char *signal) const
QObjectList	senderList () const
void	setParent_helper (QObject *)
void	setThreadData_helper (QThreadData *currentData, QThreadData *targetData)
int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...
virtual	~QObjectPrivate ()
Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Private Functions
void	addData (QGridBox *b, const QGridLayoutSizeTriple &sizes, bool r, bool c)
void	addHfwData (QGridBox *box, int width)
void	effectiveMargins (int *left, int *top, int *right, int *bottom) const
QSize	findSize (int QLayoutStruct::*, int hSpacing, int vSpacing) const
void	init ()
void	recalcHFW (int w)
void	setNextPosAfter (int r, int c)
void	setSize (int rows, int cols)
void	setupHfwLayoutData ()
void	setupLayoutData (int hSpacing, int vSpacing)
void	setupSpacings (QVector< QLayoutStruct > &chain, QGridBox *grid[], int fixedSpacing, Qt::Orientation orientation)

Properties
uint	addVertical: 1
int	bottomMargin
int	cc
QVector< int >	cMinWidths
QVector< QLayoutStruct >	colData
QVector< int >	cStretch
uint	has_hfw: 1
int	hfw_height
int	hfw_minheight
int	hfw_width
QVector< QLayoutStruct > *	hfwData
int	horizontalSpacing
uint	hReversed: 1
int	leftMargin
uint	needRecalc: 1
int	nextC
int	nextR
int	rightMargin
QVector< int >	rMinHeights
QVector< QLayoutStruct >	rowData
int	rr
QVector< int >	rStretch
QList< QGridBox * >	things
int	topMargin
int	verticalSpacing
uint	vReversed: 1

Additional Inherited Members
Public Types inherited from QLayoutPrivate
typedef QSpacerItem *(*	QSpacerItemFactoryMethod) (const QLayout *layout, int w, int h, QSizePolicy::Policy hPolicy, QSizePolicy::Policy)
typedef QWidgetItem *(*	QWidgetItemFactoryMethod) (const QLayout *layout, QWidget *widget)
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
Static Public Functions inherited from QLayoutPrivate
static QSpacerItem *	createSpacerItem (const QLayout *layout, int w, int h, QSizePolicy::Policy hPolicy=QSizePolicy::Minimum, QSizePolicy::Policy vPolicy=QSizePolicy::Minimum)
static QWidgetItem *	createWidgetItem (const QLayout *layout, QWidget *widget)
Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)
static QObjectPrivate *	get (QObject *o)
static void	resetCurrentSender (QObject *receiver, Sender *currentSender, Sender *previousSender)
static Sender *	setCurrentSender (QObject *receiver, Sender *sender)
static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)
Public Variables inherited from QLayoutPrivate
uint	activated: 1
uint	autoNewChild: 1
QLayout::SizeConstraint	constraint
uint	enabled: 1
int	insideSpacing
QWidget *	menubar
QRect	rect
uint	topLevel: 1
int	userBottomMargin
int	userLeftMargin
int	userRightMargin
int	userTopMargin
Public Variables inherited from QObjectPrivate
union {
QObject *   currentChildBeingDeleted
QAbstractDeclarativeData *   declarativeData
};
quint32	connectedSignals [2]
QObjectConnectionListVector *	connectionLists
Sender *	currentSender
QList< QPointer< QObject > >	eventFilters
ExtraData *	extraData
QString	objectName
Connection *	senders
QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount
QThreadData *	threadData
void *	unused
Public Variables inherited from QObjectData
uint	blockSig: 1
QObjectList	children
uint	hasGuards: 1
uint	inEventHandler: 1
uint	inThreadChangeEvent: 1
uint	isWidget: 1
QMetaObject *	metaObject
uint	ownObjectName: 1
QObject *	parent
uint	pendTimer: 1
int	postedEvents
QObject *	q_ptr
uint	receiveChildEvents: 1
uint	sendChildEvents: 1
uint	unused: 22
uint	wasDeleted: 1
Static Public Variables inherited from QLayoutPrivate
static QSpacerItemFactoryMethod	spacerItemFactoryMethod = 0
static QWidgetItemFactoryMethod	widgetItemFactoryMethod = 0

Detailed Description

Definition at line 107 of file qgridlayout.cpp.

Constructors and Destructors

QGridLayoutPrivate()

QGridLayoutPrivate::QGridLayoutPrivate

(

)

Definition at line 328 of file qgridlayout.cpp.

{
    addVertical = false;
    setDirty();
    rr = cc = 0;
    nextR = nextC = 0;
    hfwData = 0;
    hReversed = false;
    vReversed = false;
    horizontalSpacing = -1;
    verticalSpacing = -1;
}

Functions

add() [1/2]

void QGridLayoutPrivate::add	(	QGridBox *	box,
		int	row,
		int	col
	)

Definition at line 543 of file qgridlayout.cpp.

{
    expand(row + 1, col + 1);
    box->row = box->torow = row;
    box->col = box->tocol = col;
    things.append(box);
    setDirty();
    setNextPosAfter(row, col);
}

add() [2/2]

void QGridLayoutPrivate::add	(	QGridBox *	box,
		int	row1,
		int	row2,
		int	col1,
		int	col2
	)

Definition at line 553 of file qgridlayout.cpp.

{
    if (row2 >= 0 && row2 < row1)
        qWarning("QGridLayout: Multi-cell fromRow greater than toRow");
    if (col2 >= 0 && col2 < col1)
        qWarning("QGridLayout: Multi-cell fromCol greater than toCol");
    if (row1 == row2 && col1 == col2) {
        add(box, row1, col1);
        return;
    }
    expand(row2 + 1, col2 + 1);
    box->row = row1;
    box->col = col1;

    box->torow = row2;
    box->tocol = col2;

    things.append(box);
    setDirty();
    if (col2 < 0)
        col2 = cc - 1;

    setNextPosAfter(row2, col2);
}

addData()

void QGridLayoutPrivate::addData ( QGridBox *  b, const QGridLayoutSizeTriple &  sizes, bool  r, bool  c  )

private

Definition at line 578 of file qgridlayout.cpp.

{
    const QWidget *widget = box->item()->widget();

    if (box->isEmpty() && widget)
        return;

    if (c) {
        QLayoutStruct *data = &colData[box->col];
        if (!cStretch.at(box->col))
            data->stretch = qMax(data->stretch, box->hStretch());
        data->sizeHint = qMax(sizes.hint.width(), data->sizeHint);
        data->minimumSize = qMax(sizes.minS.width(), data->minimumSize);

        qMaxExpCalc(data->maximumSize, data->expansive, data->empty, sizes.maxS.width(),
                    box->expandingDirections() & Qt::Horizontal, box->isEmpty());
    }
    if (r) {
        QLayoutStruct *data = &rowData[box->row];
        if (!rStretch.at(box->row))
            data->stretch = qMax(data->stretch, box->vStretch());
        data->sizeHint = qMax(sizes.hint.height(), data->sizeHint);
        data->minimumSize = qMax(sizes.minS.height(), data->minimumSize);

        qMaxExpCalc(data->maximumSize, data->expansive, data->empty, sizes.maxS.height(),
                    box->expandingDirections() & Qt::Vertical, box->isEmpty());
    }
}

addHfwData()

void QGridLayoutPrivate::addHfwData ( QGridBox *  box, int  width  )

private

Definition at line 854 of file qgridlayout.cpp.

{
    QVector<QLayoutStruct> &rData = *hfwData;
    if (box->hasHeightForWidth()) {
        int hint = box->heightForWidth(width);
        rData[box->row].sizeHint = qMax(hint, rData.at(box->row).sizeHint);
        rData[box->row].minimumSize = qMax(hint, rData.at(box->row).minimumSize);
    } else {
        QSize hint = box->sizeHint();
        QSize minS = box->minimumSize();
        rData[box->row].sizeHint = qMax(hint.height(), rData.at(box->row).sizeHint);
        rData[box->row].minimumSize = qMax(minS.height(), rData.at(box->row).minimumSize);
    }
}

cellRect()

QRect QGridLayoutPrivate::cellRect	(	int	row,
		int	col
	)		const

Definition at line 968 of file qgridlayout.cpp.

{
    if (row < 0 || row >= rr || col < 0 || col >= cc)
        return QRect();

    const QVector<QLayoutStruct> *rDataPtr;
    if (has_hfw && hfwData)
        rDataPtr = hfwData;
    else
        rDataPtr = &rowData;
    return QRect(colData.at(col).pos, rDataPtr->at(row).pos,
                 colData.at(col).size, rDataPtr->at(row).size);
}

colSpacing()

int QGridLayoutPrivate::colSpacing ( int  c ) const

inline

Definition at line 137 of file qgridlayout.cpp.

{ return cMinWidths.at(c); }

colStretch()

int QGridLayoutPrivate::colStretch ( int  c ) const

inline

Definition at line 131 of file qgridlayout.cpp.

{ return cStretch.at(c); }

count()

int QGridLayoutPrivate::count ( ) const

inline

Definition at line 149 of file qgridlayout.cpp.

{ return things.count(); }

deleteAll()

void QGridLayoutPrivate::deleteAll

(

)

Definition at line 358 of file qgridlayout.cpp.

{
    while (!things.isEmpty())
        delete things.takeFirst();
    delete hfwData;
}

distribute()

void QGridLayoutPrivate::distribute	(	QRect	rect,
		int	hSpacing,
		int	vSpacing
	)

Definition at line 917 of file qgridlayout.cpp.

{
    Q_Q(QGridLayout);
    bool visualHReversed = hReversed;
    QWidget *parent = q->parentWidget();
    if (parent && parent->isRightToLeft())
        visualHReversed = !visualHReversed;

    setupLayoutData(hSpacing, vSpacing);

    int left, top, right, bottom;
    effectiveMargins(&left, &top, &right, &bottom);
    r.adjust(+left, +top, -right, -bottom);

    qGeomCalc(colData, 0, cc, r.x(), r.width());
    QVector<QLayoutStruct> *rDataPtr;
    if (has_hfw) {
        recalcHFW(r.width());
        qGeomCalc(*hfwData, 0, rr, r.y(), r.height());
        rDataPtr = hfwData;
    } else {
        qGeomCalc(rowData, 0, rr, r.y(), r.height());
        rDataPtr = &rowData;
    }
    QVector<QLayoutStruct> &rData = *rDataPtr;
    int i;

    bool reverse = ((r.bottom() > rect.bottom()) || (r.bottom() == rect.bottom()
                                                     && ((r.right() > rect.right()) != visualHReversed)));
    int n = things.size();
    for (i = 0; i < n; ++i) {
        QGridBox *box = things.at(reverse ? n-i-1 : i);
        int r2 = box->toRow(rr);
        int c2 = box->toCol(cc);

        int x = colData.at(box->col).pos;
        int y = rData.at(box->row).pos;
        int x2p = colData.at(c2).pos + colData.at(c2).size; // x2+1
        int y2p = rData.at(r2).pos + rData.at(r2).size;    // y2+1
        int w = x2p - x;
        int h = y2p - y;

        if (visualHReversed)
            x = r.left() + r.right() - x - w + 1;
        if (vReversed)
            y = r.top() + r.bottom() - y - h + 1;

        box->setGeometry(QRect(x, y, w, h));
    }
}

effectiveMargins()

void QGridLayoutPrivate::effectiveMargins ( int *  left, int *  top, int *  right, int *  bottom  ) const

private

Definition at line 233 of file qgridlayout.cpp.

{
    int l = leftMargin;
    int t = topMargin;
    int r = rightMargin;
    int b = bottomMargin;
#ifdef Q_WS_MAC
    int leftMost = INT_MAX;
    int topMost = INT_MAX;
    int rightMost = 0;
    int bottomMost = 0;

    QWidget *w = 0;
    const int n = things.count();
    for (int i = 0; i < n; ++i) {
        QGridBox *box = things.at(i);
        QLayoutItem *itm = box->item();
        w = itm->widget();
        if (w) {
            bool visualHReversed = hReversed != (w->layoutDirection() == Qt::RightToLeft);
            QRect lir = itm->geometry();
            QRect wr = w->geometry();
            if (box->col <= leftMost) {
                if (box->col < leftMost) {
                    // we found an item even closer to the margin, discard.
                    leftMost = box->col;
                    if (visualHReversed)
                        r = rightMargin;
                    else
                        l = leftMargin;
                }
                if (visualHReversed) {
                    r = qMax(r, wr.right() - lir.right());
                } else {
                    l = qMax(l, lir.left() - wr.left());
                }
            }
            if (box->row <= topMost) {
                if (box->row < topMost) {
                    // we found an item even closer to the margin, discard.
                    topMost = box->row;
                    if (vReversed)
                        b = bottomMargin;
                    else
                        t = topMargin;
                }
                if (vReversed)
                    b = qMax(b, wr.bottom() - lir.bottom());
                else
                    t = qMax(t, lir.top() - wr.top());
            }
            if (box->toCol(cc) >= rightMost) {
                if (box->toCol(cc) > rightMost) {
                    // we found an item even closer to the margin, discard.
                    rightMost = box->toCol(cc);
                    if (visualHReversed)
                        l = leftMargin;
                    else
                        r = rightMargin;
                }
                if (visualHReversed) {
                    l = qMax(l, lir.left() - wr.left());
                } else {
                    r = qMax(r, wr.right() - lir.right());
                }

            }
            if (box->toRow(rr) >= bottomMost) {
                if (box->toRow(rr) > bottomMost) {
                    // we found an item even closer to the margin, discard.
                    bottomMost = box->toRow(rr);
                    if (vReversed)
                        t = topMargin;
                    else
                        b = bottomMargin;
                }
                if (vReversed)
                    t = qMax(t, lir.top() - wr.top());
                else
                    b = qMax(b, wr.bottom() - lir.bottom());
            }
        }
    }

#endif
    if (left)
        *left = l;
    if (top)
        *top = t;
    if (right)
        *right = r;
    if (bottom)
        *bottom = b;
}

expand()

void QGridLayoutPrivate::expand ( int  rows, int  cols  )

inline

Definition at line 124 of file qgridlayout.cpp.

        { setSize(qMax(rows, rr), qMax(cols, cc)); }

expandingDirections()

Qt::Orientations QGridLayoutPrivate::expandingDirections	(	int	hSpacing,
		int	vSpacing
	)		const

Definition at line 444 of file qgridlayout.cpp.

{
    QGridLayoutPrivate *that = const_cast<QGridLayoutPrivate*>(this);
    that->setupLayoutData(hSpacing, vSpacing);
    Qt::Orientations ret;

    for (int r = 0; r < rr; r++) {
        if (rowData.at(r).expansive) {
            ret |= Qt::Vertical;
            break;
        }
    }
    for (int c = 0; c < cc; c++) {
        if (colData.at(c).expansive) {
            ret |= Qt::Horizontal;
            break;
        }
    }
    return ret;
}

findSize()

QSize QGridLayoutPrivate::findSize ( int QLayoutStruct::*  size, int  hSpacing, int  vSpacing  ) const

private

Definition at line 425 of file qgridlayout.cpp.

{
    QGridLayoutPrivate *that = const_cast<QGridLayoutPrivate*>(this);
    that->setupLayoutData(hSpacing, vSpacing);

    int w = 0;
    int h = 0;

    for (int r = 0; r < rr; r++)
        h += rowData.at(r).*size + rowData.at(r).spacing;
    for (int c = 0; c < cc; c++)
        w += colData.at(c).*size + colData.at(c).spacing;

    w = qMin(QLAYOUTSIZE_MAX, w);
    h = qMin(QLAYOUTSIZE_MAX, h);

    return QSize(w, h);
}

getItemPosition()

void QGridLayoutPrivate::getItemPosition ( int  index, int *  row, int *  column, int *  rowSpan, int *  columnSpan  )

inline

Definition at line 175 of file qgridlayout.cpp.

                                                                                          {
        if (index < things.count()) {
            QGridBox *b =  things.at(index);
            int toRow = b->toRow(rr);
            int toCol = b->toCol(cc);
            *row = b->row;
            *column = b->col;
            *rowSpan = toRow - *row + 1;
            *columnSpan = toCol - *column +1;
        }
    }

getNextPos()

void QGridLayoutPrivate::getNextPos ( int &  row, int &  col  )

inline

Definition at line 148 of file qgridlayout.cpp.

{ row = nextR; col = nextC; }

hasHeightForWidth()

bool QGridLayoutPrivate::hasHeightForWidth	(	int	hSpacing,
		int	vSpacing
	)

Definition at line 365 of file qgridlayout.cpp.

{
    setupLayoutData(hSpacing, vSpacing);
    return has_hfw;
}

heightForWidth()

int QGridLayoutPrivate::heightForWidth	(	int	width,
		int	hSpacing,
		int	vSpacing
	)

Definition at line 399 of file qgridlayout.cpp.

Referenced by QGridLayout::heightForWidth().

{
    setupLayoutData(hSpacing, vSpacing);
    if (!has_hfw)
        return -1;
    int left, top, right, bottom;
    effectiveMargins(&left, &top, &right, &bottom);

    int hMargins = left + right;
    if (w - hMargins != hfw_width) {
        qGeomCalc(colData, 0, cc, 0, w - hMargins);
        recalcHFW(w - hMargins);
    }
    return hfw_height + top + bottom;
}

horReversed()

bool QGridLayoutPrivate::horReversed ( ) const

inline

Definition at line 140 of file qgridlayout.cpp.

{ return hReversed; }

init()

void QGridLayoutPrivate::init ( )

private

isDirty()

bool QGridLayoutPrivate::isDirty ( ) const

inline

Definition at line 143 of file qgridlayout.cpp.

{ return needRecalc; }

itemAt()

QLayoutItem* QGridLayoutPrivate::itemAt ( int  index ) const

inline

Definition at line 152 of file qgridlayout.cpp.

                                                {
        if (index < things.count())
            return things.at(index)->item();
        else
            return 0;
    }

maximumSize()

QSize QGridLayoutPrivate::maximumSize	(	int	hSpacing,
		int	vSpacing
	)		const

Definition at line 470 of file qgridlayout.cpp.

{
    return findSize(&QLayoutStruct::maximumSize, hSpacing, vSpacing);
}

minimumHeightForWidth()

int QGridLayoutPrivate::minimumHeightForWidth	(	int	width,
		int	hSpacing,
		int	vSpacing
	)

Definition at line 415 of file qgridlayout.cpp.

Referenced by QGridLayout::minimumHeightForWidth().

{
    (void)heightForWidth(w, hSpacing, vSpacing);
    if (!has_hfw)
        return -1;
    int top, bottom;
    effectiveMargins(0, &top, 0, &bottom);
    return hfw_minheight + top + bottom;
}

minimumSize()

QSize QGridLayoutPrivate::minimumSize	(	int	hSpacing,
		int	vSpacing
	)		const

Definition at line 475 of file qgridlayout.cpp.

{
    return findSize(&QLayoutStruct::minimumSize, hSpacing, vSpacing);
}

numCols()

int QGridLayoutPrivate::numCols ( ) const

inline

Definition at line 123 of file qgridlayout.cpp.

{ return cc; }

numRows()

int QGridLayoutPrivate::numRows ( ) const

inline

Definition at line 122 of file qgridlayout.cpp.

{ return rr; }

recalcHFW()

void QGridLayoutPrivate::recalcHFW ( int  w )

private

Definition at line 375 of file qgridlayout.cpp.

{
    /*
      Go through all children, using colData and heightForWidth()
      and put the results in hfwData.
    */
    if (!hfwData)
        hfwData = new QVector<QLayoutStruct>(rr);
    setupHfwLayoutData();
    QVector<QLayoutStruct> &rData = *hfwData;

    int h = 0;
    int mh = 0;
    for (int r = 0; r < rr; r++) {
        int spacing = rData.at(r).spacing;
        h += rData.at(r).sizeHint + spacing;
        mh += rData.at(r).minimumSize + spacing;
    }

    hfw_width = w;
    hfw_height = qMin(QLAYOUTSIZE_MAX, h);
    hfw_minheight = qMin(QLAYOUTSIZE_MAX, mh);
}

rowSpacing()

int QGridLayoutPrivate::rowSpacing ( int  r ) const

inline

Definition at line 136 of file qgridlayout.cpp.

{ return rMinHeights.at(r); }

rowStretch()

int QGridLayoutPrivate::rowStretch ( int  r ) const

inline

Definition at line 130 of file qgridlayout.cpp.

{ return rStretch.at(r); }

setColStretch()

void QGridLayoutPrivate::setColStretch ( int  c, int  s  )

inline

Definition at line 128 of file qgridlayout.cpp.

        { expand(0, c + 1); cStretch[c] = s; setDirty(); }

setColumnMinimumWidth()

void QGridLayoutPrivate::setColumnMinimumWidth ( int  c, int  s  )

inline

Definition at line 134 of file qgridlayout.cpp.

        { expand(0, c + 1); cMinWidths[c] = s; setDirty(); }

setDirty()

void QGridLayoutPrivate::setDirty ( )

inline

Definition at line 142 of file qgridlayout.cpp.

{ needRecalc = true; hfw_width = -1; }

setNextPosAfter()

void QGridLayoutPrivate::setNextPosAfter ( int  r, int  c  )

private

Definition at line 520 of file qgridlayout.cpp.

{
    if (addVertical) {
        if (col > nextC || (col == nextC && row >= nextR)) {
            nextR = row + 1;
            nextC = col;
            if (nextR >= rr) {
                nextR = 0;
                nextC++;
            }
        }
    } else {
        if (row > nextR || (row == nextR && col >= nextC)) {
            nextR = row;
            nextC = col + 1;
            if (nextC >= cc) {
                nextC = 0;
                nextR++;
            }
        }
    }
}

setReversed()

void QGridLayoutPrivate::setReversed ( bool  r, bool  c  )

inline

Definition at line 139 of file qgridlayout.cpp.

{ hReversed = c; vReversed = r; }

setRowMinimumHeight()

void QGridLayoutPrivate::setRowMinimumHeight ( int  r, int  s  )

inline

Definition at line 132 of file qgridlayout.cpp.

        { expand(r + 1, 0); rMinHeights[r] = s; setDirty(); }

setRowStretch()

void QGridLayoutPrivate::setRowStretch ( int  r, int  s  )

inline

Definition at line 126 of file qgridlayout.cpp.

        { expand(r + 1, 0); rStretch[r] = s; setDirty(); }

setSize()

void QGridLayoutPrivate::setSize ( int  rows, int  cols  )

private

Definition at line 480 of file qgridlayout.cpp.

{
    if ((int)rowData.size() < r) {
        int newR = qMax(r, rr * 2);
        rowData.resize(newR);
        rStretch.resize(newR);
        rMinHeights.resize(newR);
        for (int i = rr; i < newR; i++) {
            rowData[i].init();
            rowData[i].maximumSize = 0;
            rowData[i].pos = 0;
            rowData[i].size = 0;
            rStretch[i] = 0;
            rMinHeights[i] = 0;
        }
    }
    if ((int)colData.size() < c) {
        int newC = qMax(c, cc * 2);
        colData.resize(newC);
        cStretch.resize(newC);
        cMinWidths.resize(newC);
        for (int i = cc; i < newC; i++) {
            colData[i].init();
            colData[i].maximumSize = 0;
            colData[i].pos = 0;
            colData[i].size = 0;
            cStretch[i] = 0;
            cMinWidths[i] = 0;
        }
    }

    if (hfwData && (int)hfwData->size() < r) {
        delete hfwData;
        hfwData = 0;
        hfw_width = -1;
    }
    rr = r;
    cc = c;
}

setupHfwLayoutData()

void QGridLayoutPrivate::setupHfwLayoutData ( )

private

Definition at line 874 of file qgridlayout.cpp.

{
    QVector<QLayoutStruct> &rData = *hfwData;
    for (int i = 0; i < rr; i++) {
        rData[i] = rowData.at(i);
        rData[i].minimumSize = rData[i].sizeHint = rMinHeights.at(i);
    }

    for (int pass = 0; pass < 2; ++pass) {
        for (int i = 0; i < things.size(); ++i) {
            QGridBox *box = things.at(i);
            int r1 = box->row;
            int c1 = box->col;
            int r2 = box->toRow(rr);
            int c2 = box->toCol(cc);
            int w = colData.at(c2).pos + colData.at(c2).size - colData.at(c1).pos;

            if (r1 == r2) {
                if (pass == 0)
                    addHfwData(box, w);
            } else {
                if (pass == 0) {
                    initEmptyMultiBox(rData, r1, r2);
                } else {
                    QSize hint = box->sizeHint();
                    QSize min = box->minimumSize();
                    if (box->hasHeightForWidth()) {
                        int hfwh = box->heightForWidth(w);
                        if (hfwh > hint.height())
                            hint.setHeight(hfwh);
                        if (hfwh > min.height())
                            min.setHeight(hfwh);
                    }
                    distributeMultiBox(rData, r1, r2, min.height(), hint.height(),
                                       rStretch, box->vStretch());
                }
            }
        }
    }
    for (int i = 0; i < rr; i++)
        rData[i].expansive = rData.at(i).expansive || rData.at(i).stretch > 0;
}

setupLayoutData()

void QGridLayoutPrivate::setupLayoutData ( int  hSpacing, int  vSpacing  )

private

Definition at line 757 of file qgridlayout.cpp.

Referenced by expandingDirections(), and findSize().

{
    Q_Q(QGridLayout);

#ifndef QT_LAYOUT_DISABLE_CACHING
    if (!needRecalc)
        return;
#endif
    has_hfw = false;
    int i;

    for (i = 0; i < rr; i++) {
        rowData[i].init(rStretch.at(i), rMinHeights.at(i));
        rowData[i].maximumSize = rStretch.at(i) ? QLAYOUTSIZE_MAX : rMinHeights.at(i);
    }
    for (i = 0; i < cc; i++) {
        colData[i].init(cStretch.at(i), cMinWidths.at(i));
        colData[i].maximumSize = cStretch.at(i) ? QLAYOUTSIZE_MAX : cMinWidths.at(i);
    }

    int n = things.size();
    QVarLengthArray<QGridLayoutSizeTriple> sizes(n);

    bool has_multi = false;

    /*
        Grid of items. We use it to determine which items are
        adjacent to which and compute the spacings correctly.
    */
    QVarLengthArray<QGridBox *> grid(rr * cc);
    qMemSet(grid.data(), 0, rr * cc * sizeof(QGridBox *));

    /*
        Initialize 'sizes' and 'grid' data structures, and insert
        non-spanning items to our row and column data structures.
    */
    for (i = 0; i < n; ++i) {
        QGridBox * const box = things.at(i);
        sizes[i].minS = box->minimumSize();
        sizes[i].hint = box->sizeHint();
        sizes[i].maxS = box->maximumSize();

        if (box->hasHeightForWidth())
            has_hfw = true;

        if (box->row == box->toRow(rr)) {
            addData(box, sizes[i], true, false);
        } else {
            initEmptyMultiBox(rowData, box->row, box->toRow(rr));
            has_multi = true;
        }

        if (box->col == box->toCol(cc)) {
            addData(box, sizes[i], false, true);
        } else {
            initEmptyMultiBox(colData, box->col, box->toCol(cc));
            has_multi = true;
        }

        for (int r = box->row; r <= box->toRow(rr); ++r) {
            for (int c = box->col; c <= box->toCol(cc); ++c) {
                gridAt(grid.data(), r, c, cc) = box;
            }
        }
    }

    setupSpacings(colData, grid.data(), hSpacing, Qt::Horizontal);
    setupSpacings(rowData, grid.data(), vSpacing, Qt::Vertical);

    /*
        Insert multicell items to our row and column data structures.
        This must be done after the non-spanning items to obtain a
        better distribution in distributeMultiBox().
    */
    if (has_multi) {
        for (i = 0; i < n; ++i) {
            QGridBox * const box = things.at(i);

            if (box->row != box->toRow(rr))
                distributeMultiBox(rowData, box->row, box->toRow(rr), sizes[i].minS.height(),
                                   sizes[i].hint.height(), rStretch, box->vStretch());
            if (box->col != box->toCol(cc))
                distributeMultiBox(colData, box->col, box->toCol(cc), sizes[i].minS.width(),
                                   sizes[i].hint.width(), cStretch, box->hStretch());
        }
    }

    for (i = 0; i < rr; i++)
        rowData[i].expansive = rowData.at(i).expansive || rowData.at(i).stretch > 0;
    for (i = 0; i < cc; i++)
        colData[i].expansive = colData.at(i).expansive || colData.at(i).stretch > 0;

    q->getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);

    needRecalc = false;
}

setupSpacings()

void QGridLayoutPrivate::setupSpacings ( QVector< QLayoutStruct > &  chain, QGridBox *  grid[], int  fixedSpacing, Qt::Orientation  orientation  )

private

Definition at line 690 of file qgridlayout.cpp.

{
    Q_Q(QGridLayout);
    int numRows = rr;       // or columns if orientation is horizontal
    int numColumns = cc;    // or rows if orientation is horizontal

    if (orientation == Qt::Horizontal) {
        qSwap(numRows, numColumns);
    }

    QStyle *style = 0;
    if (fixedSpacing < 0) {
        if (QWidget *parentWidget = q->parentWidget())
            style = parentWidget->style();
    }

    for (int c = 0; c < numColumns; ++c) {
        QGridBox *previousBox = 0;
        int previousRow = -1;       // previous *non-empty* row

        for (int r = 0; r < numRows; ++r) {
            if (chain.at(r).empty)
                continue;

            QGridBox *box = gridAt(grid, r, c, cc, orientation);
            if (previousRow != -1 && (!box || previousBox != box)) {
                int spacing = fixedSpacing;
                if (spacing < 0) {
                    QSizePolicy::ControlTypes controlTypes1 = QSizePolicy::DefaultType;
                    QSizePolicy::ControlTypes controlTypes2 = QSizePolicy::DefaultType;
                    if (previousBox)
                        controlTypes1 = previousBox->item()->controlTypes();
                    if (box)
                        controlTypes2 = box->item()->controlTypes();

                    if ((orientation == Qt::Horizontal && hReversed)
                            || (orientation == Qt::Vertical && vReversed))
                        qSwap(controlTypes1, controlTypes2);

                    if (style)
                        spacing = style->combinedLayoutSpacing(controlTypes1, controlTypes2,
                                             orientation, 0, q->parentWidget());
                } else {
                    if (orientation == Qt::Vertical) {
                        QGridBox *sibling = vReversed ? previousBox : box;
                        if (sibling) {
                            QWidget *wid = sibling->item()->widget();
                            if (wid)
                                spacing = qMax(spacing, sibling->item()->geometry().top() - wid->geometry().top() );
                        }
                    }
                }

                if (spacing > chain.at(previousRow).spacing)
                    chain[previousRow].spacing = spacing;
            }

            previousBox = box;
            previousRow = r;
        }
    }
}

sizeHint()

QSize QGridLayoutPrivate::sizeHint	(	int	hSpacing,
		int	vSpacing
	)		const

Definition at line 465 of file qgridlayout.cpp.

{
    return findSize(&QLayoutStruct::sizeHint, hSpacing, vSpacing);
}

takeAt()

QLayoutItem* QGridLayoutPrivate::takeAt ( int  index )

inline

Definition at line 158 of file qgridlayout.cpp.

                                          {
        Q_Q(QGridLayout);
        if (index < things.count()) {
            if (QGridBox *b = things.takeAt(index)) {
                QLayoutItem *item = b->takeItem();
                if (QLayout *l = item->layout()) {
                    // sanity check in case the user passed something weird to QObject::setParent()
                    if (l->parent() == q)
                        l->setParent(0);
                }
                delete b;
                return item;
            }
        }
        return 0;
    }

verReversed()

bool QGridLayoutPrivate::verReversed ( ) const

inline

Definition at line 141 of file qgridlayout.cpp.

{ return vReversed; }

Properties

addVertical

uint QGridLayoutPrivate::addVertical

private

Definition at line 230 of file qgridlayout.cpp.

bottomMargin

int QGridLayoutPrivate::bottomMargin

private

Definition at line 224 of file qgridlayout.cpp.

cc

int QGridLayoutPrivate::cc

private

Definition at line 203 of file qgridlayout.cpp.

cMinWidths

QVector<int> QGridLayoutPrivate::cMinWidths

private

Definition at line 210 of file qgridlayout.cpp.

colData

QVector<QLayoutStruct> QGridLayoutPrivate::colData

private

Definition at line 205 of file qgridlayout.cpp.

cStretch

QVector<int> QGridLayoutPrivate::cStretch

private

Definition at line 208 of file qgridlayout.cpp.

has_hfw

uint QGridLayoutPrivate::has_hfw

private

Definition at line 229 of file qgridlayout.cpp.

hfw_height

int QGridLayoutPrivate::hfw_height

private

Definition at line 214 of file qgridlayout.cpp.

hfw_minheight

int QGridLayoutPrivate::hfw_minheight

private

Definition at line 215 of file qgridlayout.cpp.

hfw_width

int QGridLayoutPrivate::hfw_width

private

Definition at line 213 of file qgridlayout.cpp.

hfwData

QVector<QLayoutStruct>* QGridLayoutPrivate::hfwData

private

Definition at line 206 of file qgridlayout.cpp.

horizontalSpacing

int QGridLayoutPrivate::horizontalSpacing

private

Definition at line 219 of file qgridlayout.cpp.

hReversed

uint QGridLayoutPrivate::hReversed

private

Definition at line 226 of file qgridlayout.cpp.

leftMargin

int QGridLayoutPrivate::leftMargin

private

Definition at line 221 of file qgridlayout.cpp.

needRecalc

uint QGridLayoutPrivate::needRecalc

private

Definition at line 228 of file qgridlayout.cpp.

nextC

int QGridLayoutPrivate::nextC

private

Definition at line 217 of file qgridlayout.cpp.

nextR

int QGridLayoutPrivate::nextR

private

Definition at line 216 of file qgridlayout.cpp.

rightMargin

int QGridLayoutPrivate::rightMargin

private

Definition at line 223 of file qgridlayout.cpp.

rMinHeights

QVector<int> QGridLayoutPrivate::rMinHeights

private

Definition at line 209 of file qgridlayout.cpp.

rowData

QVector<QLayoutStruct> QGridLayoutPrivate::rowData

private

Definition at line 204 of file qgridlayout.cpp.

rr

int QGridLayoutPrivate::rr

private

Definition at line 202 of file qgridlayout.cpp.

rStretch

QVector<int> QGridLayoutPrivate::rStretch

private

Definition at line 207 of file qgridlayout.cpp.

things

QList<QGridBox *> QGridLayoutPrivate::things

private

Definition at line 211 of file qgridlayout.cpp.

topMargin

int QGridLayoutPrivate::topMargin

private

Definition at line 222 of file qgridlayout.cpp.

verticalSpacing

int QGridLayoutPrivate::verticalSpacing

private

Definition at line 220 of file qgridlayout.cpp.

vReversed

uint QGridLayoutPrivate::vReversed

private

Definition at line 227 of file qgridlayout.cpp.

---

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

• /src/gui/kernel/qgridlayout.cpp