QDeclarativeAnchorsPrivate Class Reference

#include <qdeclarativeanchors_p_p.h>

Inheritance diagram for QDeclarativeAnchorsPrivate:

Public Functions
void	_q_widgetDestroyed (QObject *)
void	_q_widgetGeometryChanged ()
void	addDepend (QGraphicsObject *)
QDeclarativeAnchorsPrivate *	anchorPrivate ()
bool	calcStretch (const QDeclarativeAnchorLine &edge1, const QDeclarativeAnchorLine &edge2, qreal offset1, qreal offset2, QDeclarativeAnchorLine::AnchorLine line, qreal &stretch)
void	centerInChanged ()
bool	checkHAnchorValid (QDeclarativeAnchorLine anchor) const
bool	checkHValid () const
bool	checkVAnchorValid (QDeclarativeAnchorLine anchor) const
bool	checkVValid () const
void	clearItem (QGraphicsObject *)
void	fillChanged ()
bool	isItemComplete () const
bool	isMirrored () const
void	itemGeometryChanged (QDeclarativeItem *, const QRectF &, const QRectF &)
	QDeclarativeAnchorsPrivate (QGraphicsObject *i)
void	remDepend (QGraphicsObject *)
void	setItemHeight (qreal)
void	setItemPos (const QPointF &)
void	setItemSize (const QSizeF &)
void	setItemWidth (qreal)
void	setItemX (qreal)
void	setItemY (qreal)
void	updateHorizontalAnchors ()
void	updateMe ()
void	updateOnComplete ()
void	updateVerticalAnchors ()
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
Public Functions inherited from QDeclarativeItemChangeListener
virtual void	itemDestroyed (QDeclarativeItem *)
virtual void	itemOpacityChanged (QDeclarativeItem *)
virtual void	itemSiblingOrderChanged (QDeclarativeItem *)
virtual void	itemVisibilityChanged (QDeclarativeItem *)

Public Variables
QDeclarativeAnchorLine	baseline
qreal	baselineOffset
QDeclarativeAnchorLine	bottom
qreal	bottomMargin
QGraphicsObject *	centerIn
bool	componentComplete:1
QGraphicsObject *	fill
QDeclarativeAnchorLine	hCenter
qreal	hCenterOffset
QGraphicsObject *	item
QDeclarativeAnchorLine	left
qreal	leftMargin
qreal	margins
QDeclarativeAnchorLine	right
qreal	rightMargin
QDeclarativeAnchorLine	top
qreal	topMargin
uint	updatingCenterIn:2
uint	updatingFill:2
uint	updatingHorizontalAnchor:2
bool	updatingMe:1
uint	updatingVerticalAnchor:2
QDeclarativeAnchors::Anchors	usedAnchors
QDeclarativeAnchorLine	vCenter
qreal	vCenterOffset
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

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject *, QMetaObject::Call, int, void **)
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)

Detailed Description

Definition at line 89 of file qdeclarativeanchors_p_p.h.

Constructors and Destructors

QDeclarativeAnchorsPrivate()

QDeclarativeAnchorsPrivate::QDeclarativeAnchorsPrivate ( QGraphicsObject *  i )

inline

Definition at line 93 of file qdeclarativeanchors_p_p.h.

      : componentComplete(true), updatingMe(false), updatingHorizontalAnchor(0),
        updatingVerticalAnchor(0), updatingFill(0), updatingCenterIn(0), item(i), usedAnchors(0), fill(0),
        centerIn(0), leftMargin(0), rightMargin(0), topMargin(0), bottomMargin(0),
        margins(0), vCenterOffset(0), hCenterOffset(0), baselineOffset(0)
    {
    }

Functions

_q_widgetDestroyed()

void QDeclarativeAnchorsPrivate::_q_widgetDestroyed

(

QObject *

obj

)

Definition at line 393 of file qdeclarativeanchors.cpp.

{
    clearItem(qobject_cast<QGraphicsObject*>(obj));
}

_q_widgetGeometryChanged()

void QDeclarativeAnchorsPrivate::_q_widgetGeometryChanged

(

)

Definition at line 398 of file qdeclarativeanchors.cpp.

{
    fillChanged();
    centerInChanged();
    updateHorizontalAnchors();
    updateVerticalAnchors();
}

addDepend()

void QDeclarativeAnchorsPrivate::addDepend

(

QGraphicsObject *

item

)

Definition at line 269 of file qdeclarativeanchors.cpp.

{
    if (!item)
        return;
    QGraphicsItemPrivate * itemPrivate = QGraphicsItemPrivate::get(item);
    if (itemPrivate->isDeclarativeItem) {
        QDeclarativeItemPrivate *p =
            static_cast<QDeclarativeItemPrivate *>(QGraphicsItemPrivate::get(item));
        p->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
    } else if(itemPrivate->isWidget) {
        Q_Q(QDeclarativeAnchors);
        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
        QObject::connect(widget, SIGNAL(destroyed(QObject*)), q, SLOT(_q_widgetDestroyed(QObject*)));
        QObject::connect(widget, SIGNAL(geometryChanged()), q, SLOT(_q_widgetGeometryChanged()));
    }
}

anchorPrivate()

QDeclarativeAnchorsPrivate* QDeclarativeAnchorsPrivate::anchorPrivate ( )

inlinevirtual

Reimplemented from QDeclarativeItemChangeListener.

Definition at line 128 of file qdeclarativeanchors_p_p.h.

{ return this; }

calcStretch()

bool QDeclarativeAnchorsPrivate::calcStretch	(	const QDeclarativeAnchorLine &	edge1,
		const QDeclarativeAnchorLine &	edge2,
		qreal	offset1,
		qreal	offset2,
		QDeclarativeAnchorLine::AnchorLine	line,
		qreal &	stretch
	)

Definition at line 485 of file qdeclarativeanchors.cpp.

{
    bool edge1IsParent = (edge1.item == item->parentItem());
    bool edge2IsParent = (edge2.item == item->parentItem());
    bool edge1IsSibling = (edge1.item->parentItem() == item->parentItem());
    bool edge2IsSibling = (edge2.item->parentItem() == item->parentItem());

    bool invalid = false;
    if ((edge2IsParent && edge1IsParent) || (edge2IsSibling && edge1IsSibling)) {
        stretch = (position(edge2.item, edge2.anchorLine) + offset2)
                    - (position(edge1.item, edge1.anchorLine) + offset1);
    } else if (edge2IsParent && edge1IsSibling) {
        stretch = (position(edge2.item, edge2.anchorLine) + offset2)
                    - (position(item->parentObject(), line)
                    + position(edge1.item, edge1.anchorLine) + offset1);
    } else if (edge2IsSibling && edge1IsParent) {
        stretch = (position(item->parentObject(), line) + position(edge2.item, edge2.anchorLine) + offset2)
                    - (position(edge1.item, edge1.anchorLine) + offset1);
    } else
        invalid = true;

    return invalid;
}

centerInChanged()

void QDeclarativeAnchorsPrivate::centerInChanged

(

)

Definition at line 203 of file qdeclarativeanchors.cpp.

{
    Q_Q(QDeclarativeAnchors);
    if (!centerIn || fill || !isItemComplete())
        return;

    if (updatingCenterIn < 2) {
        ++updatingCenterIn;

        qreal effectiveHCenterOffset = q->mirrored() ? -hCenterOffset : hCenterOffset;
        if (centerIn == item->parentItem()) {
            QPointF p(hcenter(item->parentItem()) - hcenter(item) + effectiveHCenterOffset,
                      vcenter(item->parentItem()) - vcenter(item) + vCenterOffset);
            setItemPos(p);

        } else if (centerIn->parentItem() == item->parentItem()) {
            QPointF p(centerIn->x() + hcenter(centerIn) - hcenter(item) + effectiveHCenterOffset,
                      centerIn->y() + vcenter(centerIn) - vcenter(item) + vCenterOffset);
            setItemPos(p);
        }

        --updatingCenterIn;
    } else {
        // ### Make this certain :)
        qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on centerIn.");
    }
}

checkHAnchorValid()

bool QDeclarativeAnchorsPrivate::checkHAnchorValid

(

QDeclarativeAnchorLine

anchor

)

const

Definition at line 1106 of file qdeclarativeanchors.cpp.

{
    if (!anchor.item) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor to a null item.");
        return false;
    } else if (anchor.anchorLine & QDeclarativeAnchorLine::Vertical_Mask) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor a horizontal edge to a vertical edge.");
        return false;
    } else if (anchor.item != item->parentItem() && anchor.item->parentItem() != item->parentItem()){
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor to an item that isn't a parent or sibling.");
        return false;
    } else if (anchor.item == item) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor item to self.");
        return false;
    }

    return true;
}

checkHValid()

bool QDeclarativeAnchorsPrivate::checkHValid

(

)

const

Definition at line 1094 of file qdeclarativeanchors.cpp.

{
    if (usedAnchors & QDeclarativeAnchors::LeftAnchor &&
        usedAnchors & QDeclarativeAnchors::RightAnchor &&
        usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot specify left, right, and hcenter anchors.");
        return false;
    }

    return true;
}

checkVAnchorValid()

bool QDeclarativeAnchorsPrivate::checkVAnchorValid

(

QDeclarativeAnchorLine

anchor

)

const

Definition at line 1143 of file qdeclarativeanchors.cpp.

{
    if (!anchor.item) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor to a null item.");
        return false;
    } else if (anchor.anchorLine & QDeclarativeAnchorLine::Horizontal_Mask) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor a vertical edge to a horizontal edge.");
        return false;
    } else if (anchor.item != item->parentItem() && anchor.item->parentItem() != item->parentItem()){
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor to an item that isn't a parent or sibling.");
        return false;
    } else if (anchor.item == item){
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot anchor item to self.");
        return false;
    }

    return true;
}

checkVValid()

bool QDeclarativeAnchorsPrivate::checkVValid

(

)

const

Definition at line 1125 of file qdeclarativeanchors.cpp.

{
    if (usedAnchors & QDeclarativeAnchors::TopAnchor &&
        usedAnchors & QDeclarativeAnchors::BottomAnchor &&
        usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Cannot specify top, bottom, and vcenter anchors.");
        return false;
    } else if (usedAnchors & QDeclarativeAnchors::BaselineAnchor &&
               (usedAnchors & QDeclarativeAnchors::TopAnchor ||
                usedAnchors & QDeclarativeAnchors::BottomAnchor ||
                usedAnchors & QDeclarativeAnchors::VCenterAnchor)) {
        qmlInfo(item) << QDeclarativeAnchors::tr("Baseline anchor cannot be used in conjunction with top, bottom, or vcenter anchors.");
        return false;
    }

    return true;
}

clearItem()

void QDeclarativeAnchorsPrivate::clearItem

(

QGraphicsObject *

item

)

Definition at line 231 of file qdeclarativeanchors.cpp.

Referenced by QDeclarativeItem::~QDeclarativeItem().

{
    if (!item)
        return;
    if (fill == item)
        fill = 0;
    if (centerIn == item)
        centerIn = 0;
    if (left.item == item) {
        left.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::LeftAnchor;
    }
    if (right.item == item) {
        right.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::RightAnchor;
    }
    if (top.item == item) {
        top.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::TopAnchor;
    }
    if (bottom.item == item) {
        bottom.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::BottomAnchor;
    }
    if (vCenter.item == item) {
        vCenter.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::VCenterAnchor;
    }
    if (hCenter.item == item) {
        hCenter.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::HCenterAnchor;
    }
    if (baseline.item == item) {
        baseline.item = 0;
        usedAnchors &= ~QDeclarativeAnchors::BaselineAnchor;
    }
}

fillChanged()

void QDeclarativeAnchorsPrivate::fillChanged

(

)

Definition at line 176 of file qdeclarativeanchors.cpp.

{
    Q_Q(QDeclarativeAnchors);
    if (!fill || !isItemComplete())
        return;

    if (updatingFill < 2) {
        ++updatingFill;

        qreal horizontalMargin = q->mirrored() ? rightMargin : leftMargin;

        if (fill == item->parentItem()) {                         //child-parent
            setItemPos(QPointF(horizontalMargin, topMargin));
        } else if (fill->parentItem() == item->parentItem()) {   //siblings
            setItemPos(QPointF(fill->x()+horizontalMargin, fill->y()+topMargin));
        }
        QGraphicsItemPrivate *fillPrivate = QGraphicsItemPrivate::get(fill);
        setItemSize(QSizeF(fillPrivate->width()-leftMargin-rightMargin, fillPrivate->height()-topMargin-bottomMargin));

        --updatingFill;
    } else {
        // ### Make this certain :)
        qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on fill.");
    }

}

isItemComplete()

bool QDeclarativeAnchorsPrivate::isItemComplete

(

)

const

Definition at line 303 of file qdeclarativeanchors.cpp.

{
    return componentComplete;
}

isMirrored()

bool QDeclarativeAnchorsPrivate::isMirrored

(

)

const

itemGeometryChanged()

void QDeclarativeAnchorsPrivate::itemGeometryChanged ( QDeclarativeItem *  , const QRectF &  newG, const QRectF &  oldG  )

virtual

Reimplemented from QDeclarativeItemChangeListener.

Definition at line 406 of file qdeclarativeanchors.cpp.

{
    fillChanged();
    centerInChanged();
    if (newG.x() != oldG.x() || newG.width() != oldG.width())
        updateHorizontalAnchors();
    if (newG.y() != oldG.y() || newG.height() != oldG.height())
        updateVerticalAnchors();
}

remDepend()

void QDeclarativeAnchorsPrivate::remDepend

(

QGraphicsObject *

item

)

Definition at line 286 of file qdeclarativeanchors.cpp.

{
    if (!item)
        return;
    QGraphicsItemPrivate * itemPrivate = QGraphicsItemPrivate::get(item);
    if (itemPrivate->isDeclarativeItem) {
        QDeclarativeItemPrivate *p =
            static_cast<QDeclarativeItemPrivate *>(itemPrivate);
        p->removeItemChangeListener(this, QDeclarativeItemPrivate::Geometry);
    } else if(itemPrivate->isWidget) {
        Q_Q(QDeclarativeAnchors);
        QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
        QObject::disconnect(widget, SIGNAL(destroyed(QObject*)), q, SLOT(_q_widgetDestroyed(QObject*)));
        QObject::disconnect(widget, SIGNAL(geometryChanged()), q, SLOT(_q_widgetGeometryChanged()));
    }
}

setItemHeight()

void QDeclarativeAnchorsPrivate::setItemHeight

(

qreal

v

)

Definition at line 327 of file qdeclarativeanchors.cpp.

{
    updatingMe = true;
    QGraphicsItemPrivate::get(item)->setHeight(v);
    updatingMe = false;
}

setItemPos()

void QDeclarativeAnchorsPrivate::setItemPos

(

const QPointF &

v

)

Definition at line 355 of file qdeclarativeanchors.cpp.

{
    updatingMe = true;
    item->setPos(v);
    updatingMe = false;
}

setItemSize()

void QDeclarativeAnchorsPrivate::setItemSize

(

const QSizeF &

v

)

Definition at line 362 of file qdeclarativeanchors.cpp.

{
    updatingMe = true;
    if(QGraphicsItemPrivate::get(item)->isWidget)
        static_cast<QGraphicsWidget *>(item)->resize(v);
    else if (QGraphicsItemPrivate::get(item)->isDeclarativeItem)
        static_cast<QDeclarativeItem *>(item)->setSize(v);
    updatingMe = false;
}

setItemWidth()

void QDeclarativeAnchorsPrivate::setItemWidth

(

qreal

v

)

Definition at line 334 of file qdeclarativeanchors.cpp.

{
    updatingMe = true;
    QGraphicsItemPrivate::get(item)->setWidth(v);
    updatingMe = false;
}

setItemX()

void QDeclarativeAnchorsPrivate::setItemX

(

qreal

v

)

Definition at line 341 of file qdeclarativeanchors.cpp.

{
    updatingMe = true;
    item->setX(v);
    updatingMe = false;
}

setItemY()

void QDeclarativeAnchorsPrivate::setItemY

(

qreal

v

)

Definition at line 348 of file qdeclarativeanchors.cpp.

{
    updatingMe = true;
    item->setY(v);
    updatingMe = false;
}

updateHorizontalAnchors()

void QDeclarativeAnchorsPrivate::updateHorizontalAnchors

(

)

Definition at line 596 of file qdeclarativeanchors.cpp.

{
    Q_Q(QDeclarativeAnchors);
    if (fill || centerIn || !isItemComplete())
        return;

    if (updatingHorizontalAnchor < 3) {
        ++updatingHorizontalAnchor;
        qreal effectiveRightMargin, effectiveLeftMargin, effectiveHorizontalCenterOffset;
        QDeclarativeAnchorLine effectiveLeft, effectiveRight, effectiveHorizontalCenter;
        QDeclarativeAnchors::Anchor effectiveLeftAnchor, effectiveRightAnchor;
        if (q->mirrored()) {
            effectiveLeftAnchor = QDeclarativeAnchors::RightAnchor;
            effectiveRightAnchor = QDeclarativeAnchors::LeftAnchor;
            effectiveLeft.item = right.item;
            effectiveLeft.anchorLine = reverseAnchorLine(right.anchorLine);
            effectiveRight.item = left.item;
            effectiveRight.anchorLine = reverseAnchorLine(left.anchorLine);
            effectiveHorizontalCenter.item = hCenter.item;
            effectiveHorizontalCenter.anchorLine = reverseAnchorLine(hCenter.anchorLine);
            effectiveLeftMargin = rightMargin;
            effectiveRightMargin = leftMargin;
            effectiveHorizontalCenterOffset = -hCenterOffset;
        } else {
            effectiveLeftAnchor = QDeclarativeAnchors::LeftAnchor;
            effectiveRightAnchor = QDeclarativeAnchors::RightAnchor;
            effectiveLeft = left;
            effectiveRight = right;
            effectiveHorizontalCenter = hCenter;
            effectiveLeftMargin = leftMargin;
            effectiveRightMargin = rightMargin;
            effectiveHorizontalCenterOffset = hCenterOffset;
        }

        QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);
        if (usedAnchors & effectiveLeftAnchor) {
            //Handle stretching
            bool invalid = true;
            qreal width = 0.0;
            if (usedAnchors & effectiveRightAnchor) {
                invalid = calcStretch(effectiveLeft, effectiveRight, effectiveLeftMargin, -effectiveRightMargin, QDeclarativeAnchorLine::Left, width);
            } else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
                invalid = calcStretch(effectiveLeft, effectiveHorizontalCenter, effectiveLeftMargin, effectiveHorizontalCenterOffset, QDeclarativeAnchorLine::Left, width);
                width *= 2;
            }
            if (!invalid)
                setItemWidth(width);

            //Handle left
            if (effectiveLeft.item == item->parentItem()) {
                setItemX(adjustedPosition(effectiveLeft.item, effectiveLeft.anchorLine) + effectiveLeftMargin);
            } else if (effectiveLeft.item->parentItem() == item->parentItem()) {
                setItemX(position(effectiveLeft.item, effectiveLeft.anchorLine) + effectiveLeftMargin);
            }
        } else if (usedAnchors & effectiveRightAnchor) {
            //Handle stretching (left + right case is handled in updateLeftAnchor)
            if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
                qreal width = 0.0;
                bool invalid = calcStretch(effectiveHorizontalCenter, effectiveRight, effectiveHorizontalCenterOffset, -effectiveRightMargin,
                                              QDeclarativeAnchorLine::Left, width);
                if (!invalid)
                    setItemWidth(width*2);
            }

            //Handle right
            if (effectiveRight.item == item->parentItem()) {
                setItemX(adjustedPosition(effectiveRight.item, effectiveRight.anchorLine) - itemPrivate->width() - effectiveRightMargin);
            } else if (effectiveRight.item->parentItem() == item->parentItem()) {
                setItemX(position(effectiveRight.item, effectiveRight.anchorLine) - itemPrivate->width() - effectiveRightMargin);
            }
        } else if (usedAnchors & QDeclarativeAnchors::HCenterAnchor) {
            //Handle hCenter
            if (effectiveHorizontalCenter.item == item->parentItem()) {
                setItemX(adjustedPosition(effectiveHorizontalCenter.item, effectiveHorizontalCenter.anchorLine) - hcenter(item) + effectiveHorizontalCenterOffset);
            } else if (effectiveHorizontalCenter.item->parentItem() == item->parentItem()) {
                setItemX(position(effectiveHorizontalCenter.item, effectiveHorizontalCenter.anchorLine) - hcenter(item) + effectiveHorizontalCenterOffset);
            }
        }
        --updatingHorizontalAnchor;
    } else {
        // ### Make this certain :)
        qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on horizontal anchor.");
    }
}

updateMe()

void QDeclarativeAnchorsPrivate::updateMe

(

)

Definition at line 372 of file qdeclarativeanchors.cpp.

{
    if (updatingMe) {
        updatingMe = false;
        return;
    }

    fillChanged();
    centerInChanged();
    updateHorizontalAnchors();
    updateVerticalAnchors();
}

updateOnComplete()

void QDeclarativeAnchorsPrivate::updateOnComplete

(

)

Definition at line 385 of file qdeclarativeanchors.cpp.

Referenced by QDeclarativeItem::~QDeclarativeItem().

{
    fillChanged();
    centerInChanged();
    updateHorizontalAnchors();
    updateVerticalAnchors();
}

updateVerticalAnchors()

void QDeclarativeAnchorsPrivate::updateVerticalAnchors

(

)

Definition at line 514 of file qdeclarativeanchors.cpp.

Referenced by QDeclarativeItem::setBaselineOffset().

{
    if (fill || centerIn || !isItemComplete())
        return;

    if (updatingVerticalAnchor < 2) {
        ++updatingVerticalAnchor;
        QGraphicsItemPrivate *itemPrivate = QGraphicsItemPrivate::get(item);
        if (usedAnchors & QDeclarativeAnchors::TopAnchor) {
            //Handle stretching
            bool invalid = true;
            qreal height = 0.0;
            if (usedAnchors & QDeclarativeAnchors::BottomAnchor) {
                invalid = calcStretch(top, bottom, topMargin, -bottomMargin, QDeclarativeAnchorLine::Top, height);
            } else if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
                invalid = calcStretch(top, vCenter, topMargin, vCenterOffset, QDeclarativeAnchorLine::Top, height);
                height *= 2;
            }
            if (!invalid)
                setItemHeight(height);

            //Handle top
            if (top.item == item->parentItem()) {
                setItemY(adjustedPosition(top.item, top.anchorLine) + topMargin);
            } else if (top.item->parentItem() == item->parentItem()) {
                setItemY(position(top.item, top.anchorLine) + topMargin);
            }
        } else if (usedAnchors & QDeclarativeAnchors::BottomAnchor) {
            //Handle stretching (top + bottom case is handled above)
            if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
                qreal height = 0.0;
                bool invalid = calcStretch(vCenter, bottom, vCenterOffset, -bottomMargin,
                                              QDeclarativeAnchorLine::Top, height);
                if (!invalid)
                    setItemHeight(height*2);
            }

            //Handle bottom
            if (bottom.item == item->parentItem()) {
                setItemY(adjustedPosition(bottom.item, bottom.anchorLine) - itemPrivate->height() - bottomMargin);
            } else if (bottom.item->parentItem() == item->parentItem()) {
                setItemY(position(bottom.item, bottom.anchorLine) - itemPrivate->height() - bottomMargin);
            }
        } else if (usedAnchors & QDeclarativeAnchors::VCenterAnchor) {
            //(stetching handled above)

            //Handle vCenter
            if (vCenter.item == item->parentItem()) {
                setItemY(adjustedPosition(vCenter.item, vCenter.anchorLine)
                              - vcenter(item) + vCenterOffset);
            } else if (vCenter.item->parentItem() == item->parentItem()) {
                setItemY(position(vCenter.item, vCenter.anchorLine) - vcenter(item) + vCenterOffset);
            }
        } else if (usedAnchors & QDeclarativeAnchors::BaselineAnchor) {
            //Handle baseline
            if (baseline.item == item->parentItem()) {
                if (itemPrivate->isDeclarativeItem)
                    setItemY(adjustedPosition(baseline.item, baseline.anchorLine)
                        - static_cast<QDeclarativeItem *>(item)->baselineOffset() + baselineOffset);
            } else if (baseline.item->parentItem() == item->parentItem()) {
                if (itemPrivate->isDeclarativeItem)
                    setItemY(position(baseline.item, baseline.anchorLine)
                        - static_cast<QDeclarativeItem *>(item)->baselineOffset() + baselineOffset);
            }
        }
        --updatingVerticalAnchor;
    } else {
        // ### Make this certain :)
        qmlInfo(item) << QDeclarativeAnchors::tr("Possible anchor loop detected on vertical anchor.");
    }
}

Properties

baseline

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::baseline

Definition at line 154 of file qdeclarativeanchors_p_p.h.

baselineOffset

qreal QDeclarativeAnchorsPrivate::baselineOffset

Definition at line 163 of file qdeclarativeanchors_p_p.h.

bottom

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::bottom

Definition at line 151 of file qdeclarativeanchors_p_p.h.

bottomMargin

qreal QDeclarativeAnchorsPrivate::bottomMargin

Definition at line 159 of file qdeclarativeanchors_p_p.h.

centerIn

QGraphicsObject* QDeclarativeAnchorsPrivate::centerIn

Definition at line 146 of file qdeclarativeanchors_p_p.h.

componentComplete

bool QDeclarativeAnchorsPrivate::componentComplete

Definition at line 107 of file qdeclarativeanchors_p_p.h.

fill

QGraphicsObject* QDeclarativeAnchorsPrivate::fill

Definition at line 145 of file qdeclarativeanchors_p_p.h.

hCenter

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::hCenter

Definition at line 153 of file qdeclarativeanchors_p_p.h.

hCenterOffset

qreal QDeclarativeAnchorsPrivate::hCenterOffset

Definition at line 162 of file qdeclarativeanchors_p_p.h.

item

QGraphicsObject* QDeclarativeAnchorsPrivate::item

Definition at line 142 of file qdeclarativeanchors_p_p.h.

Referenced by QDeclarativeItem::~QDeclarativeItem().

left

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::left

Definition at line 148 of file qdeclarativeanchors_p_p.h.

leftMargin

qreal QDeclarativeAnchorsPrivate::leftMargin

Definition at line 156 of file qdeclarativeanchors_p_p.h.

margins

qreal QDeclarativeAnchorsPrivate::margins

Definition at line 160 of file qdeclarativeanchors_p_p.h.

right

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::right

Definition at line 149 of file qdeclarativeanchors_p_p.h.

rightMargin

qreal QDeclarativeAnchorsPrivate::rightMargin

Definition at line 157 of file qdeclarativeanchors_p_p.h.

top

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::top

Definition at line 150 of file qdeclarativeanchors_p_p.h.

topMargin

qreal QDeclarativeAnchorsPrivate::topMargin

Definition at line 158 of file qdeclarativeanchors_p_p.h.

updatingCenterIn

uint QDeclarativeAnchorsPrivate::updatingCenterIn

Definition at line 112 of file qdeclarativeanchors_p_p.h.

updatingFill

uint QDeclarativeAnchorsPrivate::updatingFill

Definition at line 111 of file qdeclarativeanchors_p_p.h.

updatingHorizontalAnchor

uint QDeclarativeAnchorsPrivate::updatingHorizontalAnchor

Definition at line 109 of file qdeclarativeanchors_p_p.h.

updatingMe

bool QDeclarativeAnchorsPrivate::updatingMe

Definition at line 108 of file qdeclarativeanchors_p_p.h.

updatingVerticalAnchor

uint QDeclarativeAnchorsPrivate::updatingVerticalAnchor

Definition at line 110 of file qdeclarativeanchors_p_p.h.

usedAnchors

QDeclarativeAnchors::Anchors QDeclarativeAnchorsPrivate::usedAnchors

Definition at line 143 of file qdeclarativeanchors_p_p.h.

vCenter

QDeclarativeAnchorLine QDeclarativeAnchorsPrivate::vCenter

Definition at line 152 of file qdeclarativeanchors_p_p.h.

vCenterOffset

qreal QDeclarativeAnchorsPrivate::vCenterOffset

Definition at line 161 of file qdeclarativeanchors_p_p.h.

---

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

• /src/declarative/graphicsitems/qdeclarativeanchors_p_p.h
• /src/declarative/graphicsitems/qdeclarativeanchors.cpp