qgraphicswidget_p.cpp File Reference

#include "qglobal.h"
#include <QtCore/qdebug.h>
#include <QtCore/qnumeric.h>
#include "qgraphicswidget_p.h"
#include "qgraphicslayoutitem_p.h"
#include "qgraphicslayout.h"
#include "qgraphicsscene_p.h"
#include <QtGui/qapplication.h>
#include <QtGui/qgraphicsscene.h>
#include <QtGui/qstyleoption.h>
#include <QtGui/QStyleOptionTitleBar>
#include <QtGui/QGraphicsSceneMouseEvent>
#include <QMacStyle>
#include "moc_qgraphicswidget.cpp"

Go to the source code of this file.

Functions
static void	_q_boundGeometryToSizeConstraints (const QRectF &startGeometry, QRectF *rect, Qt::WindowFrameSection section, const QSizeF &min, const QSizeF &max, const QGraphicsWidget *widget)
static QSizeF	closestAcceptableSize (const QSizeF &proposed, const QGraphicsWidget *widget)
static qreal	minimumHeightForWidth (qreal width, qreal minh, qreal maxh, const QGraphicsWidget *widget, bool heightForWidth=true)
	Used to calculate the Precondition: widget should support either hfw or wfh. More...
static qreal	minimumWidthForHeight (qreal height, qreal minw, qreal maxw, const QGraphicsWidget *widget)

Function Documentation

_q_boundGeometryToSizeConstraints()

static void _q_boundGeometryToSizeConstraints ( const QRectF &  startGeometry, QRectF *  rect, Qt::WindowFrameSection  section, const QSizeF &  min, const QSizeF &  max, const QGraphicsWidget *  widget  )

static

Definition at line 520 of file qgraphicswidget_p.cpp.

Referenced by QGraphicsWidgetPrivate::windowFrameMouseMoveEvent().

{
    const QRectF proposedRect = *rect;
    qreal width = qBound(min.width(), proposedRect.width(), max.width());
    qreal height = qBound(min.height(), proposedRect.height(), max.height());

    const bool hasHFW = QGraphicsLayoutItemPrivate::get(widget)->hasHeightForWidth();
    const bool hasWFH = QGraphicsLayoutItemPrivate::get(widget)->hasWidthForHeight();

    const bool widthChanged = proposedRect.width() != widget->size().width();
    const bool heightChanged = proposedRect.height() != widget->size().height();

    if (hasHFW || hasWFH) {
        if (widthChanged || heightChanged) {
            qreal minExtent;
            qreal maxExtent;
            qreal constraint;
            qreal proposed;
            if (hasHFW) {
                minExtent = min.height();
                maxExtent = max.height();
                constraint = width;
                proposed = proposedRect.height();
            } else {
                // width for height
                minExtent = min.width();
                maxExtent = max.width();
                constraint = height;
                proposed = proposedRect.width();
            }
            if (minimumHeightForWidth(constraint, minExtent, maxExtent, widget, hasHFW) > proposed) {
                QSizeF effectiveSize = closestAcceptableSize(QSizeF(width, height), widget);
                width = effectiveSize.width();
                height = effectiveSize.height();
            }
        }
    }

    switch (section) {
    case Qt::LeftSection:
        rect->setRect(startGeometry.right() - qRound(width), startGeometry.top(),
                      qRound(width), startGeometry.height());
        break;
    case Qt::TopLeftSection:
        rect->setRect(startGeometry.right() - qRound(width), startGeometry.bottom() - qRound(height),
                      qRound(width), qRound(height));
        break;
    case Qt::TopSection:
        rect->setRect(startGeometry.left(), startGeometry.bottom() - qRound(height),
                      startGeometry.width(), qRound(height));
        break;
    case Qt::TopRightSection:
        rect->setTop(rect->bottom() - qRound(height));
        rect->setWidth(qRound(width));
        break;
    case Qt::RightSection:
        rect->setWidth(qRound(width));
        break;
    case Qt::BottomRightSection:
        rect->setWidth(qRound(width));
        rect->setHeight(qRound(height));
        break;
    case Qt::BottomSection:
        rect->setHeight(qRound(height));
        break;
    case Qt::BottomLeftSection:
        rect->setRect(startGeometry.right() - qRound(width), startGeometry.top(),
                      qRound(width), qRound(height));
        break;
    default:
        break;
    }
}

closestAcceptableSize()

static QSizeF closestAcceptableSize ( const QSizeF &  proposed, const QGraphicsWidget *  widget  )

static

Definition at line 473 of file qgraphicswidget_p.cpp.

Referenced by _q_boundGeometryToSizeConstraints().

{
    const QSizeF current = widget->size();

    qreal minw = proposed.width();
    qreal maxw = current.width();
    qreal minh = proposed.height();
    qreal maxh = current.height();

    qreal middlew = maxw;
    qreal middleh = maxh;
    qreal min_hfw;
    min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget);

    do {
        if (maxw - minw < 0.1) {
            // we still havent found anything, cut off binary search
            minw = maxw;
            minh = maxh;
        }
        middlew = minw + (maxw - minw)/qreal(2.0);
        middleh = minh + (maxh - minh)/qreal(2.0);

        min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);

        if (min_hfw > middleh) {
            minw = middlew;
            minh = middleh;
        } else if (min_hfw <= middleh) {
            maxw = middlew;
            maxh = middleh;
        }
    } while (maxw != minw);

    min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);

    QSizeF result;
    if (min_hfw < maxh) {
        result = QSizeF(middlew, min_hfw);
    } else {
        // Needed because of the cut-off we do above.
        result = QSizeF(minimumWidthForHeight(maxh, proposed.width(), current.width(), widget), maxh);
    }
    return result;
}

minimumHeightForWidth()

static qreal minimumHeightForWidth ( qreal  width, qreal  minh, qreal  maxh, const QGraphicsWidget *  widget, bool  heightForWidth = true  )

static

Used to calculate the Precondition: widget should support either hfw or wfh.

If heightForWidth is set to false, this function will query the width for height instead. width will then be interpreted as height, minh and maxh will be interpreted as minimum width and maximum width.

Definition at line 435 of file qgraphicswidget_p.cpp.

Referenced by _q_boundGeometryToSizeConstraints(), QLayout::activate(), closestAcceptableSize(), QGridLayoutPrivate::isDirty(), and minimumWidthForHeight().

{
    qreal minimumHeightForWidth = -1;
    const bool hasHFW = QGraphicsLayoutItemPrivate::get(widget)->hasHeightForWidth();
    if (hasHFW == heightForWidth) {
        minimumHeightForWidth = hasHFW
                                ? widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(width, -1)).height()
                                : widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, width)).width();    //"width" is here height!
    } else {
        // widthForHeight
        const qreal constraint = width;
        while (maxh - minh > 0.1) {
            qreal middle = minh + (maxh - minh)/2;
            // ### really bad, if we are a widget with a layout it will call
            // layout->effectiveSizeHint(Qt::MiniumumSize), which again will call
            // sizeHint three times because of how the cache works
            qreal hfw = hasHFW
                        ? widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(middle, -1)).height()
                        : widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, middle)).width();
            if (hfw > constraint) {
                minh = middle;
            } else if (hfw <= constraint) {
                maxh = middle;
            }
        }
        minimumHeightForWidth = maxh;
    }
    return minimumHeightForWidth;
}

minimumWidthForHeight()

static qreal minimumWidthForHeight ( qreal  height, qreal  minw, qreal  maxw, const QGraphicsWidget *  widget  )

static

Definition at line 467 of file qgraphicswidget_p.cpp.

Referenced by closestAcceptableSize().

{
    return minimumHeightForWidth(height, minw, maxw, widget, false);
}