ParallelAnchorData Struct Reference

#include <qgraphicsanchorlayout_p.h>

Inheritance diagram for ParallelAnchorData:

Public Functions
bool	calculateSizeHints ()
	ParallelAnchorData (AnchorData *first, AnchorData *second)
bool	secondForward () const
virtual void	updateChildrenSizes ()
Public Functions inherited from AnchorData
	AnchorData ()
void	dump (int indent=2)
void	refreshSizeHints (const QLayoutStyleInfo *styleInfo=0)
QString	toString () const
virtual	~AnchorData ()
Public Functions inherited from QSimplexVariable
	QSimplexVariable ()

Public Variables
AnchorData *	firstEdge
QList< QSimplexConstraint * >	m_firstConstraints
QList< QSimplexConstraint * >	m_secondConstraints
AnchorData *	secondEdge
Public Variables inherited from AnchorData
uint	dependency: 2
AnchorVertex *	from
QGraphicsAnchor *	graphicsAnchor
uint	isCenterAnchor: 1
uint	isLayoutAnchor: 1
QGraphicsLayoutItem *	item
qreal	maxPrefSize
qreal	maxSize
qreal	minPrefSize
qreal	minSize
QString	name
uint	orientation: 1
qreal	prefSize
qreal	sizeAtMaximum
qreal	sizeAtMinimum
qreal	sizeAtPreferred
AnchorVertex *	to
uint	type: 2
Public Variables inherited from QSimplexVariable
int	index
qreal	result

Additional Inherited Members
Public Types inherited from AnchorData
enum	Dependency { Independent = 0, Master, Slave }
enum	Type { Normal = 0, Sequential, Parallel }

Detailed Description

Definition at line 210 of file qgraphicsanchorlayout_p.h.

Constructors and Destructors

ParallelAnchorData()

ParallelAnchorData::ParallelAnchorData ( AnchorData *  first, AnchorData *  second  )

inline

Definition at line 212 of file qgraphicsanchorlayout_p.h.

        : AnchorData(), firstEdge(first), secondEdge(second)
    {
        type = AnchorData::Parallel;
        orientation = first->orientation;

        // This assert whether the child anchors share their vertices
        Q_ASSERT(((first->from == second->from) && (first->to == second->to)) ||
                 ((first->from == second->to) && (first->to == second->from)));

        // Our convention will be that the parallel group anchor will have the same
        // direction as the first anchor.
        from = first->from;
        to = first->to;
#ifdef QT_DEBUG
        name = QString::fromAscii("%1 | %2").arg(first->toString(), second->toString());
#endif
    }

Functions

calculateSizeHints()

bool ParallelAnchorData::calculateSizeHints

(

)

Definition at line 298 of file qgraphicsanchorlayout_p.cpp.

Referenced by QGraphicsAnchorLayoutPrivate::addAnchorMaybeParallel().

{
    // Normalize second child sizes.
    // A negative anchor of sizes min, minPref, pref, maxPref and max, is equivalent
    // to a forward anchor of sizes -max, -maxPref, -pref, -minPref, -min
    qreal secondMin;
    qreal secondMinPref;
    qreal secondPref;
    qreal secondMaxPref;
    qreal secondMax;

    if (secondForward()) {
        secondMin = secondEdge->minSize;
        secondMinPref = secondEdge->minPrefSize;
        secondPref = secondEdge->prefSize;
        secondMaxPref = secondEdge->maxPrefSize;
        secondMax = secondEdge->maxSize;
    } else {
        secondMin = -secondEdge->maxSize;
        secondMinPref = -secondEdge->maxPrefSize;
        secondPref = -secondEdge->prefSize;
        secondMaxPref = -secondEdge->minPrefSize;
        secondMax = -secondEdge->minSize;
    }

    minSize = qMax(firstEdge->minSize, secondMin);
    maxSize = qMin(firstEdge->maxSize, secondMax);

    // This condition means that the maximum size of one anchor being simplified is smaller than
    // the minimum size of the other anchor. The consequence is that there won't be a valid size
    // for this parallel setup.
    if (minSize > maxSize) {
        return false;
    }

    // Preferred size calculation
    // The calculation of preferred size is done as follows:
    //
    // 1) Check whether one of the child anchors is the layout structural anchor
    //    If so, we can simply copy the preferred information from the other child,
    //    after bounding it to our minimum and maximum sizes.
    //    If not, then we proceed with the actual calculations.
    //
    // 2) The whole algorithm for preferred size calculation is based on the fact
    //    that, if a given anchor cannot remain at its preferred size, it'd rather
    //    grow than shrink.
    //
    //    What happens though is that while this affirmative is true for simple
    //    anchors, it may not be true for sequential anchors that have one or more
    //    reversed anchors inside it. That happens because when a sequential anchor
    //    grows, any reversed anchors inside it may be required to shrink, something
    //    we try to avoid, as said above.
    //
    //    To overcome this, besides their actual preferred size "prefSize", each anchor
    //    exports what we call "minPrefSize" and "maxPrefSize". These two values define
    //    a surrounding interval where, if required to move, the anchor would rather
    //    remain inside.
    //
    //    For standard anchors, this area simply represents the region between
    //    prefSize and maxSize, which makes sense since our first affirmation.
    //    For composed anchors, these values are calculated as to reduce the global
    //    "damage", that is, to reduce the total deviation and the total amount of
    //    anchors that had to shrink.

    if (firstEdge->isLayoutAnchor) {
        prefSize = qBound(minSize, secondPref, maxSize);
        minPrefSize = qBound(minSize, secondMinPref, maxSize);
        maxPrefSize = qBound(minSize, secondMaxPref, maxSize);
    } else if (secondEdge->isLayoutAnchor) {
        prefSize = qBound(minSize, firstEdge->prefSize, maxSize);
        minPrefSize = qBound(minSize, firstEdge->minPrefSize, maxSize);
        maxPrefSize = qBound(minSize, firstEdge->maxPrefSize, maxSize);
    } else {
        // Calculate the intersection between the "preferred" regions of each child
        const qreal lowerBoundary =
            qBound(minSize, qMax(firstEdge->minPrefSize, secondMinPref), maxSize);
        const qreal upperBoundary =
            qBound(minSize, qMin(firstEdge->maxPrefSize, secondMaxPref), maxSize);
        const qreal prefMean =
            qBound(minSize, (firstEdge->prefSize + secondPref) / 2, maxSize);

        if (lowerBoundary < upperBoundary) {
            // If there is an intersection between the two regions, this intersection
            // will be used as the preferred region of the parallel anchor itself.
            // The preferred size will be the bounded average between the two preferred
            // sizes.
            prefSize = qBound(lowerBoundary, prefMean, upperBoundary);
            minPrefSize = lowerBoundary;
            maxPrefSize = upperBoundary;
        } else {
            // If there is no intersection, we have to attribute "damage" to at least
            // one of the children. The minimum total damage is achieved in points
            // inside the region that extends from (1) the upper boundary of the lower
            // region to (2) the lower boundary of the upper region.
            // Then, we expose this region as _our_ preferred region and once again,
            // use the bounded average as our preferred size.
            prefSize = qBound(upperBoundary, prefMean, lowerBoundary);
            minPrefSize = upperBoundary;
            maxPrefSize = lowerBoundary;
        }
    }

    // See comment in AnchorData::refreshSizeHints() about sizeAt* values
    sizeAtMinimum = prefSize;
    sizeAtPreferred = prefSize;
    sizeAtMaximum = prefSize;

    return true;
}

secondForward()

bool ParallelAnchorData::secondForward ( ) const

inline

Definition at line 234 of file qgraphicsanchorlayout_p.h.

Referenced by QGraphicsAnchorLayoutPrivate::addAnchorMaybeParallel(), and QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints().

                               {
        // We have the convention that the first children will define the direction of the
        // pararell group. Note that we can't rely on 'this->from' or 'this->to'  because they
        // might be changed by vertex simplification.
        return firstEdge->from == secondEdge->from;
    }

updateChildrenSizes()

void ParallelAnchorData::updateChildrenSizes ( )

virtual

Reimplemented from AnchorData.

Definition at line 268 of file qgraphicsanchorlayout_p.cpp.

{
    firstEdge->sizeAtMinimum = sizeAtMinimum;
    firstEdge->sizeAtPreferred = sizeAtPreferred;
    firstEdge->sizeAtMaximum = sizeAtMaximum;

    if (secondForward()) {
        secondEdge->sizeAtMinimum = sizeAtMinimum;
        secondEdge->sizeAtPreferred = sizeAtPreferred;
        secondEdge->sizeAtMaximum = sizeAtMaximum;
    } else {
        secondEdge->sizeAtMinimum = -sizeAtMinimum;
        secondEdge->sizeAtPreferred = -sizeAtPreferred;
        secondEdge->sizeAtMaximum = -sizeAtMaximum;
    }

    firstEdge->updateChildrenSizes();
    secondEdge->updateChildrenSizes();
}

Properties

firstEdge

AnchorData* ParallelAnchorData::firstEdge

Definition at line 241 of file qgraphicsanchorlayout_p.h.

Referenced by AnchorData::dump(), QGraphicsAnchorLayoutPrivate::restoreSimplifiedAnchor(), and QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints().

m_firstConstraints

QList<QSimplexConstraint *> ParallelAnchorData::m_firstConstraints

Definition at line 244 of file qgraphicsanchorlayout_p.h.

Referenced by QGraphicsAnchorLayoutPrivate::addAnchorMaybeParallel(), and QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints().

m_secondConstraints

QList<QSimplexConstraint *> ParallelAnchorData::m_secondConstraints

Definition at line 245 of file qgraphicsanchorlayout_p.h.

Referenced by QGraphicsAnchorLayoutPrivate::addAnchorMaybeParallel(), and QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints().

secondEdge

AnchorData* ParallelAnchorData::secondEdge

Definition at line 242 of file qgraphicsanchorlayout_p.h.

Referenced by AnchorData::dump(), QGraphicsAnchorLayoutPrivate::restoreSimplifiedAnchor(), and QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints().

---

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

• /src/gui/graphicsview/qgraphicsanchorlayout_p.h
• /src/gui/graphicsview/qgraphicsanchorlayout_p.cpp