QGraphicsLayoutItemPrivate Class Reference

#include <qgraphicslayoutitem_p.h>

Inheritance diagram for QGraphicsLayoutItemPrivate:

Public Types
enum	SizeComponent { Width, Height }

Public Functions
QSizeF *	effectiveSizeHints (const QSizeF &constraint) const
void	ensureUserSizeHints ()
	Ensures that userSizeHints is allocated. More...
bool	hasHeightForWidth () const
bool	hasWidthForHeight () const
void	init ()
QGraphicsItem *	parentItem () const
	Returns the parent item of this layout, or 0 if this layout is not installed on any widget. More...
	QGraphicsLayoutItemPrivate (QGraphicsLayoutItem *parent, bool isLayout)
void	setSize (Qt::SizeHint which, const QSizeF &size)
	Sets the user size hint which to size. More...
void	setSizeComponent (Qt::SizeHint which, SizeComponent component, qreal value)
	Sets the width of the user size hint which to width. More...
virtual	~QGraphicsLayoutItemPrivate ()

Static Public Functions
static QGraphicsLayoutItemPrivate *	get (QGraphicsLayoutItem *q)
static const QGraphicsLayoutItemPrivate *	get (const QGraphicsLayoutItem *q)

Public Variables
QSizeF	cachedConstraint
QSizeF	cachedSizeHints [Qt::NSizeHints]
QSizeF	cachedSizeHintsWithConstraints [Qt::NSizeHints]
QRectF	geom
QGraphicsItem *	graphicsItem
quint32	isLayout: 1
quint32	ownedByLayout: 1
QGraphicsLayoutItem *	parent
QGraphicsLayoutItem *	q_ptr
quint32	sizeHintCacheDirty: 1
quint32	sizeHintWithConstraintCacheDirty: 1
QSizePolicy	sizePolicy
QSizeF *	userSizeHints

Detailed Description

Definition at line 62 of file qgraphicslayoutitem_p.h.

Enumerations

SizeComponent

enum QGraphicsLayoutItemPrivate::SizeComponent

Enumerator
Width
Height

Definition at line 76 of file qgraphicslayoutitem_p.h.

{ Width, Height };

Constructors and Destructors

~QGraphicsLayoutItemPrivate()

QGraphicsLayoutItemPrivate::~QGraphicsLayoutItemPrivate ( )

virtual

Warning

This function is not part of the public interface.

Definition at line 119 of file qgraphicslayoutitem.cpp.

{
    // Remove any lazily allocated data
    delete[] userSizeHints;
}

QGraphicsLayoutItemPrivate()

QGraphicsLayoutItemPrivate::QGraphicsLayoutItemPrivate	(	QGraphicsLayoutItem *	par,
		bool	layout
	)

Warning

This function is not part of the public interface.

Definition at line 111 of file qgraphicslayoutitem.cpp.

    : parent(par), userSizeHints(0), isLayout(layout), ownedByLayout(false), graphicsItem(0)
{
}

Functions

effectiveSizeHints()

QSizeF * QGraphicsLayoutItemPrivate::effectiveSizeHints

(

const QSizeF &

constraint

)

const

Warning

This function is not part of the public interface.

effectiveSizeHint has a quirky behavior, one of the quirkinesses is when the hfw function is combined with user-specified min/max sizes. The input to hfw function (e.g width) must be within the min/max width constraint, and the output must be within the min/max height. This sets up a loose dependency between minimum width and maximum height (or minimum height, depending on the type of hfw function). Note that its only the concrete subclass that implements that hfw function that knows if this dependency means that the height will increase or decrease when the width is increased.

The application should try to ensure that the user-defined sizes are within the range so that they don't conflict with the hfw function.

Suppose, for instance that the hfw function is:

height = 2000/width

and the item has these user-defined sizes:

min  ( 5,  5)
pref(100, 10)
max (500,100)

what is the return value if one calls item->effectiveSizeHint(Qt::MinimumSize, QSizeF(10, -1)); ? The sizeHint() function would return QSizeF(10, 200), but it would be bounded down to 100 due to the max value, so it would return (10, 100). This is not what the item expects, since it really wants that its hfw is respected. If this is a label with wrapped text, this would most likely lead to that some text is clipped. This is certainly not what the app developer wants. Now, it would be better if the user changed those constraints to match the hfw function:

min ( 20,  5)
pref(100, 10)
max (500,100)

here, it says that the width cannot be smaller than 20. This is because if it becomes smaller than 20 the result of the hfw function would violate the max height (100).

However, there is a similar problem if the width passed to the hfw function reaches max width:

the sizeHint() function would now return QSizeF(500, 4), but 4 is smaller than the minimum height (5), so effectiveSizeHint() would return (500, 5), which would leave too much space. In this case, setting the max width to 400 fixes the problem:

min ( 20,  5)
pref(100, 10)
max (400,100)

The implementor of a hfw widget must be aware of this when sizeHint() is reimplemented, so that the default min and max sizes works sensible. (unfortunately the implementor does not have the control over user-set values).

Definition at line 188 of file qgraphicslayoutitem.cpp.

Referenced by QGraphicsLayoutItem::effectiveSizeHint().

{
    Q_Q(const QGraphicsLayoutItem);
    QSizeF *sizeHintCache;
    const bool hasConstraint = constraint.width() >= 0 || constraint.height() >= 0;
    QSizeF adjustedConstraint = constraint;
    if (hasConstraint) {
        if (!sizeHintWithConstraintCacheDirty && constraint == cachedConstraint)
            return cachedSizeHintsWithConstraints;

        const QSizeF *hintsWithoutConstraint = effectiveSizeHints(QSizeF(-1,-1));

        if (adjustedConstraint.width() >= 0)
            adjustedConstraint.setWidth( qBound( hintsWithoutConstraint[Qt::MinimumSize].width(),
                                                 adjustedConstraint.width(),
                                                 hintsWithoutConstraint[Qt::MaximumSize].width()));
        if (adjustedConstraint.height() >= 0)
            adjustedConstraint.setHeight( qBound( hintsWithoutConstraint[Qt::MinimumSize].height(),
                                                  adjustedConstraint.height(),
                                                  hintsWithoutConstraint[Qt::MaximumSize].height()));

        if (!sizeHintWithConstraintCacheDirty && adjustedConstraint == cachedConstraint)
            return cachedSizeHintsWithConstraints;
        sizeHintCache = cachedSizeHintsWithConstraints;
    } else {
        if (!sizeHintCacheDirty)
            return cachedSizeHints;
        sizeHintCache = cachedSizeHints;
    }

    for (int i = 0; i < Qt::NSizeHints; ++i) {
        sizeHintCache[i] = adjustedConstraint;
        if (userSizeHints)
            combineSize(sizeHintCache[i], userSizeHints[i]);
    }

    QSizeF &minS = sizeHintCache[Qt::MinimumSize];
    QSizeF &prefS = sizeHintCache[Qt::PreferredSize];
    QSizeF &maxS = sizeHintCache[Qt::MaximumSize];
    QSizeF &descentS = sizeHintCache[Qt::MinimumDescent];

    normalizeHints(minS.rwidth(), prefS.rwidth(), maxS.rwidth(), descentS.rwidth());
    normalizeHints(minS.rheight(), prefS.rheight(), maxS.rheight(), descentS.rheight());

    // if the minimum, preferred and maximum sizes contradict each other
    // (e.g. the minimum is larger than the maximum) we give priority to
    // the maximum size, then the minimum size and finally the preferred size
    COMBINE_SIZE(maxS, q->sizeHint(Qt::MaximumSize, maxS));
    combineSize(maxS, QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
    expandSize(maxS, prefS);
    expandSize(maxS, minS);
    boundSize(maxS, QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));

    COMBINE_SIZE(minS, q->sizeHint(Qt::MinimumSize, minS));
    expandSize(minS, QSizeF(0, 0));
    boundSize(minS, prefS);
    boundSize(minS, maxS);

    COMBINE_SIZE(prefS, q->sizeHint(Qt::PreferredSize, prefS));
    expandSize(prefS, minS);
    boundSize(prefS, maxS);

    // Not supported yet
    // COMBINE_SIZE(descentS, q->sizeHint(Qt::MinimumDescent, constraint));

    if (hasConstraint) {
        cachedConstraint = adjustedConstraint;
        sizeHintWithConstraintCacheDirty = false;
    } else {
        sizeHintCacheDirty = false;
    }
    return sizeHintCache;
}

ensureUserSizeHints()

void QGraphicsLayoutItemPrivate::ensureUserSizeHints

(

)

Ensures that userSizeHints is allocated.

Warning

This function is not part of the public interface.

This function must be called before any dereferencing.

Definition at line 302 of file qgraphicslayoutitem.cpp.

Referenced by setSize(), and setSizeComponent().

{
    if (!userSizeHints)
        userSizeHints = new QSizeF[Qt::NSizeHints];
}

get() [1/2]

static QGraphicsLayoutItemPrivate* QGraphicsLayoutItemPrivate::get ( QGraphicsLayoutItem *  q )

inlinestatic

Definition at line 68 of file qgraphicslayoutitem_p.h.

Referenced by _q_boundGeometryToSizeConstraints(), QGridLayoutItem::dynamicConstraintOrientation(), QGridLayoutItem::hasDynamicConstraint(), hasHeightForWidth(), hasWidthForHeight(), and minimumHeightForWidth().

{ return q->d_func();}

get() [2/2]

static const QGraphicsLayoutItemPrivate* QGraphicsLayoutItemPrivate::get ( const QGraphicsLayoutItem *  q )

inlinestatic

Definition at line 69 of file qgraphicslayoutitem_p.h.

{ return q->d_func();}

hasHeightForWidth()

bool QGraphicsLayoutItemPrivate::hasHeightForWidth

(

)

const

Definition at line 355 of file qgraphicslayoutitem.cpp.

Referenced by _q_boundGeometryToSizeConstraints(), QGridLayoutItem::hasDynamicConstraint(), and minimumHeightForWidth().

{
    Q_Q(const QGraphicsLayoutItem);
    if (isLayout) {
        const QGraphicsLayout *l = static_cast<const QGraphicsLayout *>(q);
        for (int i = l->count() - 1; i >= 0; --i) {
            if (QGraphicsLayoutItemPrivate::get(l->itemAt(i))->hasHeightForWidth())
                return true;
        }
    } else if (QGraphicsItem *item = q->graphicsItem()) {
        if (item->isWidget()) {
            QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);
            if (w->layout()) {
                return QGraphicsLayoutItemPrivate::get(w->layout())->hasHeightForWidth();
            }
        }
    }
    return q->sizePolicy().hasHeightForWidth();
}

hasWidthForHeight()

bool QGraphicsLayoutItemPrivate::hasWidthForHeight

(

)

const

Definition at line 375 of file qgraphicslayoutitem.cpp.

Referenced by _q_boundGeometryToSizeConstraints(), and QGridLayoutItem::hasDynamicConstraint().

{
    Q_Q(const QGraphicsLayoutItem);
    if (isLayout) {
        const QGraphicsLayout *l = static_cast<const QGraphicsLayout *>(q);
        for (int i = l->count() - 1; i >= 0; --i) {
            if (QGraphicsLayoutItemPrivate::get(l->itemAt(i))->hasWidthForHeight())
                return true;
        }
    } else if (QGraphicsItem *item = q->graphicsItem()) {
        if (item->isWidget()) {
            QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);
            if (w->layout()) {
                return QGraphicsLayoutItemPrivate::get(w->layout())->hasWidthForHeight();
            }
        }
    }
    return q->sizePolicy().hasWidthForHeight();
}

init()

void QGraphicsLayoutItemPrivate::init

(

)

Warning

This function is not part of the public interface.

Definition at line 128 of file qgraphicslayoutitem.cpp.

{
    sizeHintCacheDirty = true;
    sizeHintWithConstraintCacheDirty = true;
}

parentItem()

QGraphicsItem * QGraphicsLayoutItemPrivate::parentItem

(

)

const

Returns the parent item of this layout, or 0 if this layout is not installed on any widget.

Warning

This function is not part of the public interface.

If this is the item that the layout is installed on, it will return "itself".

If the layout is a sub-layout, this function returns the parent widget of the parent layout.

Note that it will traverse up the layout item hierarchy instead of just calling QGraphicsItem::parentItem(). This is on purpose.

See also

parent()

Definition at line 282 of file qgraphicslayoutitem.cpp.

Referenced by QGraphicsLayoutPrivate::addChildLayoutItem(), QGraphicsLayoutPrivate::getMargin(), QGraphicsGridLayoutPrivate::styleInfo(), QGraphicsLinearLayoutPrivate::styleInfo(), QGraphicsAnchorLayoutPrivate::styleInfo(), and QGraphicsLayoutPrivate::visualDirection().

{
    Q_Q(const QGraphicsLayoutItem);

    const QGraphicsLayoutItem *parent = q;
    while (parent && parent->isLayout()) {
        parent = parent->parentLayoutItem();
    }
    return parent ? parent->graphicsItem() : 0;
}

setSize()

void QGraphicsLayoutItemPrivate::setSize	(	Qt::SizeHint	which,
		const QSizeF &	size
	)

Sets the user size hint which to size.

Warning

This function is not part of the public interface.

Use an invalid size to unset the size hint.

Definition at line 316 of file qgraphicslayoutitem.cpp.

Referenced by QGraphicsLayoutItem::setMaximumSize(), QGraphicsLayoutItem::setMinimumSize(), and QGraphicsLayoutItem::setPreferredSize().

{
    Q_Q(QGraphicsLayoutItem);

    if (userSizeHints) {
        if (size == userSizeHints[which])
            return;
    } else if (size.width() < 0 && size.height() < 0) {
        return;
    }

    ensureUserSizeHints();
    userSizeHints[which] = size;
    q->updateGeometry();
}

setSizeComponent()

void QGraphicsLayoutItemPrivate::setSizeComponent	(	Qt::SizeHint	which,
		SizeComponent	component,
		qreal	value
	)

Sets the width of the user size hint which to width.

Warning

This function is not part of the public interface.

Definition at line 340 of file qgraphicslayoutitem.cpp.

Referenced by QGraphicsLayoutItem::setMaximumHeight(), QGraphicsLayoutItem::setMaximumWidth(), QGraphicsLayoutItem::setMinimumHeight(), QGraphicsLayoutItem::setMinimumWidth(), QGraphicsLayoutItem::setPreferredHeight(), and QGraphicsLayoutItem::setPreferredWidth().

{
    Q_Q(QGraphicsLayoutItem);
    ensureUserSizeHints();
    qreal &userValue = (component == Width)
        ? userSizeHints[which].rwidth()
        : userSizeHints[which].rheight();
    if (value == userValue)
        return;
    userValue = value;
    q->updateGeometry();
}

Properties

cachedConstraint

QSizeF QGraphicsLayoutItemPrivate::cachedConstraint

mutable

Definition at line 87 of file qgraphicslayoutitem_p.h.

Referenced by effectiveSizeHints().

cachedSizeHints

QSizeF QGraphicsLayoutItemPrivate::cachedSizeHints[Qt::NSizeHints]

mutable

Definition at line 86 of file qgraphicslayoutitem_p.h.

Referenced by effectiveSizeHints().

cachedSizeHintsWithConstraints

QSizeF QGraphicsLayoutItemPrivate::cachedSizeHintsWithConstraints[Qt::NSizeHints]

mutable

Definition at line 88 of file qgraphicslayoutitem_p.h.

Referenced by effectiveSizeHints().

geom

QRectF QGraphicsLayoutItemPrivate::geom

Definition at line 96 of file qgraphicslayoutitem_p.h.

Referenced by QGraphicsWidget::setGeometry().

graphicsItem

QGraphicsItem* QGraphicsLayoutItemPrivate::graphicsItem

Definition at line 97 of file qgraphicslayoutitem_p.h.

isLayout

quint32 QGraphicsLayoutItemPrivate::isLayout

Definition at line 92 of file qgraphicslayoutitem_p.h.

Referenced by hasHeightForWidth(), and hasWidthForHeight().

ownedByLayout

quint32 QGraphicsLayoutItemPrivate::ownedByLayout

Definition at line 93 of file qgraphicslayoutitem_p.h.

parent

QGraphicsLayoutItem* QGraphicsLayoutItemPrivate::parent

Definition at line 83 of file qgraphicslayoutitem_p.h.

Referenced by QGraphicsLayoutPrivate::getMargin(), parentItem(), and QGraphicsAnchorLayoutPrivate::styleInfo().

q_ptr

QGraphicsLayoutItem* QGraphicsLayoutItemPrivate::q_ptr

Definition at line 95 of file qgraphicslayoutitem_p.h.

sizeHintCacheDirty

quint32 QGraphicsLayoutItemPrivate::sizeHintCacheDirty

mutable

Definition at line 90 of file qgraphicslayoutitem_p.h.

Referenced by effectiveSizeHints(), and init().

sizeHintWithConstraintCacheDirty

quint32 QGraphicsLayoutItemPrivate::sizeHintWithConstraintCacheDirty

mutable

Definition at line 91 of file qgraphicslayoutitem_p.h.

Referenced by effectiveSizeHints(), and init().

sizePolicy

QSizePolicy QGraphicsLayoutItemPrivate::sizePolicy

Definition at line 82 of file qgraphicslayoutitem_p.h.

userSizeHints

QSizeF* QGraphicsLayoutItemPrivate::userSizeHints

Definition at line 85 of file qgraphicslayoutitem_p.h.

Referenced by effectiveSizeHints(), ensureUserSizeHints(), setSize(), setSizeComponent(), and ~QGraphicsLayoutItemPrivate().

---

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

• /src/gui/graphicsview/qgraphicslayoutitem_p.h
• /src/gui/graphicsview/qgraphicslayoutitem.cpp