#include <QtGui/qapplication.h>

#ifndef QT_NO_GRAPHICSVIEW

// To ensure that all variables inside the simplex solver are non-negative,

// we limit the size of anchors in the interval [-limit, limit]. Then before

// sending them to the simplex solver we add "limit" as an offset, so that

// they are actually calculated in the interval [0, 2 * limit]

// To avoid numerical errors in platforms where we use single precision,

// we use a tighter limit for the variables range.

const qreal g_offset = (sizeof(qreal) == sizeof(double)) ? QWIDGETSIZE_MAX : QWIDGETSIZE_MAX / 32;

      sizePolicy(QSizePolicy::Fixed), preferredSize(0),

      hasSize(true)

    if (data) {

        // The QGraphicsAnchor was already deleted at this moment. We must clean

        // the dangling pointer to avoid double deletion in the AnchorData dtor.

        data->graphicsAnchor = 0;

        layoutPrivate->removeAnchor(data->from, data->to);

    }

    if (!data) {

        return;

    if (hasSize && (preferredSize == value))

        return;

    // The anchor has an user-defined size

    hasSize = true;

    preferredSize = value;

    layoutPrivate->q_func()->invalidate();

    if (!data) {

        return;

    // Return to standard direction

    hasSize = false;

    layoutPrivate->q_func()->invalidate();

    if (!data) {

        return 0;

    return preferredSize;

static void applySizePolicy(QSizePolicy::Policy policy,

                            qreal minSizeHint, qreal prefSizeHint, qreal maxSizeHint,

                            qreal *minSize, qreal *prefSize,

                            qreal *maxSize)

AnchorData::~AnchorData()

    if (graphicsAnchor) {

        // Remove reference to ourself to avoid double removal in

        // QGraphicsAnchorPrivate dtor.

        graphicsAnchor->d_func()->data = 0;

        delete graphicsAnchor;

    }

}

void AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo)

{

    if (item) {

        // It is an internal anchor, fetch size information from the item

            if (isCenterAnchor)

            minPrefSize = prefSize;

            maxPrefSize = maxSize;

            if (orientation == QGraphicsAnchorLayoutPrivate::Horizontal) {

            if (isCenterAnchor) {

        // It is a user-created anchor, fetch size information from the associated QGraphicsAnchor

        QGraphicsAnchorPrivate *anchorPrivate = graphicsAnchor->d_func();

        // Policy, min and max sizes are straightforward

        policy = anchorPrivate->sizePolicy;

        maxSizeHint = QWIDGETSIZE_MAX;

        // Preferred Size

        if (anchorPrivate->hasSize) {

            // Anchor has user-defined size

            prefSizeHint = anchorPrivate->preferredSize;

            // Fetch size information from style

            const Qt::Orientation orient = Qt::Orientation(QGraphicsAnchorLayoutPrivate::edgeOrientation(from->m_edge) + 1);

            qreal s = styleInfo->defaultSpacing(orient);

            if (s < 0) {

                QSizePolicy::ControlType controlTypeFrom = from->m_item->sizePolicy().controlType();

                QSizePolicy::ControlType controlTypeTo = to->m_item->sizePolicy().controlType();

                s = styleInfo->perItemSpacing(controlTypeFrom, controlTypeTo, orient);

                // ### Currently we do not support negative anchors inside the graph.

                // To avoid those being created by a negative style spacing, we must

                // make this test.

                if (s < 0)

                    s = 0;

            }

            prefSizeHint = s;

    // Fill minSize, prefSize and maxSize based on policy and sizeHints

    applySizePolicy(policy, minSizeHint, prefSizeHint, maxSizeHint,

                    &minSize, &prefSize, &maxSize);

    minPrefSize = prefSize;

    maxPrefSize = maxSize;

    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;

    }

/*

  \internal

  Initialize the parallel anchor size hints using the sizeHint information from

  its children.

  Note that parallel groups can lead to unfeasibility, so during calculation, we can

  find out one unfeasibility. Because of that this method return boolean. This can't

  happen in sequential, so there the method is void.

 */

bool ParallelAnchorData::calculateSizeHints()

    // 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;

        }

    }

    return true;

                                                                      qreal minPref, qreal pref,

                                                                      qreal maxPref, qreal max)

    if (value < minPref) {

        interval = QGraphicsAnchorLayoutPrivate::MinimumToMinPreferred;

        upper = minPref;

    } else if (value < pref) {

        interval = QGraphicsAnchorLayoutPrivate::MinPreferredToPreferred;

        lower = minPref;

    } else if (value < maxPref) {

        interval = QGraphicsAnchorLayoutPrivate::PreferredToMaxPreferred;

        upper = maxPref;

        interval = QGraphicsAnchorLayoutPrivate::MaxPreferredToMaximum;

        lower = maxPref;

                         qreal min, qreal minPref, qreal pref, qreal maxPref, qreal max)

    case QGraphicsAnchorLayoutPrivate::MinimumToMinPreferred:

        upper = minPref;

        break;

    case QGraphicsAnchorLayoutPrivate::MinPreferredToPreferred:

        lower = minPref;

    case QGraphicsAnchorLayoutPrivate::PreferredToMaxPreferred:

        upper = maxPref;

    case QGraphicsAnchorLayoutPrivate::MaxPreferredToMaximum:

        lower = maxPref;

        getFactor(sizeAtMinimum, minSize, minPrefSize, prefSize, maxPrefSize, maxSize);

        getFactor(sizeAtPreferred, minSize, minPrefSize, prefSize, maxPrefSize, maxSize);

        getFactor(sizeAtMaximum, minSize, minPrefSize, prefSize, maxPrefSize, maxSize);

    // XXX This is not safe if Vertex simplification takes place after the sequential

    // anchor is created. In that case, "prev" will be a group-vertex, different from

    // "from" or "to", that _contains_ one of them.

    AnchorVertex *prev = from;

        const bool edgeIsForward = (e->from == prev);

        if (edgeIsForward) {

            e->sizeAtMinimum = interpolate(minFactor, e->minSize, e->minPrefSize,

                                           e->prefSize, e->maxPrefSize, e->maxSize);

            e->sizeAtPreferred = interpolate(prefFactor, e->minSize, e->minPrefSize,

                                           e->prefSize, e->maxPrefSize, e->maxSize);

            e->sizeAtMaximum = interpolate(maxFactor, e->minSize, e->minPrefSize,