qquickflipable.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickflipable_p.h"
#include "qquickitem_p.h"
#include "qquicktranslate_p.h"
 
#include <QtQml/qqmlinfo.h>
 
QT_BEGIN_NAMESPACE
 
// XXX todo - i think this needs work and a bit of a re-think
 
class QQuickLocalTransform : public QQuickTransform
{
    Q_OBJECT
public:
    QQuickLocalTransform(QObject *parent) : QQuickTransform(parent) {}
 
    void setTransform(const QTransform &t) {
        transform = t;
        update();
    }
    void applyTo(QMatrix4x4 *matrix) const override {
        *matrix *= transform;
    }
private:
    QTransform transform;
};
 
class QQuickFlipablePrivate : public QQuickItemPrivate
{
    Q_DECLARE_PUBLIC(QQuickFlipable)
public:
    QQuickFlipablePrivate() : current(QQuickFlipable::Front), front(nullptr), back(nullptr), sideDirty(false) {}
 
    bool transformChanged(QQuickItem *transformedItem) override;
    void updateSide();
    void setBackTransform();
 
    QQuickFlipable::Side current;
    QPointer<QQuickLocalTransform> backTransform;
    QPointer<QQuickItem> front;
    QPointer<QQuickItem> back;
 
    bool sideDirty;
    bool wantBackXFlipped;
    bool wantBackYFlipped;
};
 
QQuickFlipable::QQuickFlipable(QQuickItem *parent)
: QQuickItem(*(new QQuickFlipablePrivate), parent)
{
}
 
QQuickFlipable::~QQuickFlipable()
{
}
 
QQuickItem *QQuickFlipable::front() const
{
    Q_D(const QQuickFlipable);
    return d->front;
}
 
void QQuickFlipable::setFront(QQuickItem *front)
{
    Q_D(QQuickFlipable);
    if (d->front) {
        qmlWarning(this) << tr("front is a write-once property");
        return;
    }
    d->front = front;
    d->front->setParentItem(this);
    if (Back == d->current) {
        d->front->setOpacity(0.);
        d->front->setEnabled(false);
    }
    emit frontChanged();
}
 
QQuickItem *QQuickFlipable::back()
{
    Q_D(const QQuickFlipable);
    return d->back;
}
 
void QQuickFlipable::setBack(QQuickItem *back)
{
    Q_D(QQuickFlipable);
    if (d->back) {
        qmlWarning(this) << tr("back is a write-once property");
        return;
    }
    if (back == nullptr)
        return;
    d->back = back;
    d->back->setParentItem(this);
 
    d->backTransform = new QQuickLocalTransform(d->back);
    d->backTransform->prependToItem(d->back);
 
    if (Front == d->current) {
        d->back->setOpacity(0.);
        d->back->setEnabled(false);
    }
 
    connect(back, SIGNAL(widthChanged()),
            this, SLOT(retransformBack()));
    connect(back, SIGNAL(heightChanged()),
            this, SLOT(retransformBack()));
    emit backChanged();
}
 
void QQuickFlipable::retransformBack()
{
    Q_D(QQuickFlipable);
    if (d->current == QQuickFlipable::Back && d->back)
        d->setBackTransform();
}
 
QQuickFlipable::Side QQuickFlipable::side() const
{
    Q_D(const QQuickFlipable);
 
    const_cast<QQuickFlipablePrivate *>(d)->updateSide();
    return d->current;
}
 
bool QQuickFlipablePrivate::transformChanged(QQuickItem *transformedItem)
{
    Q_Q(QQuickFlipable);
 
    if (!sideDirty) {
        sideDirty = true;
        q->polish();
    }
 
    return QQuickItemPrivate::transformChanged(transformedItem);
}
 
void QQuickFlipable::updatePolish()
{
    Q_D(QQuickFlipable);
    d->updateSide();
}
 
void QQuickFlipablePrivate::updateSide()
{
    Q_Q(QQuickFlipable);
 
    if (!sideDirty)
        return;
 
    sideDirty = false;
 
    QMatrix4x4 sceneTransform;
 
    const qreal tx = x.value();
    const qreal ty = y.value();
    if (!qFuzzyIsNull(tx) || !qFuzzyIsNull(ty))
        sceneTransform.translate(tx, ty);
 
    for (const auto *transform : std::as_const(transforms)) {
        if (const auto *rot = qobject_cast<const QQuickRotation *>(transform)) {
            // rotation is a special case: we want to call rotate() instead of projectedRotate()
            const auto angle = rot->angle();
            const auto axis = rot->axis();
            if (!(qFuzzyIsNull(angle) || axis.isNull())) {
                sceneTransform.translate(rot->origin());
                sceneTransform.rotate(angle, axis.x(), axis.y(), axis.z());
                sceneTransform.translate(-rot->origin());
            }
        } else {
            transform->applyTo(&sceneTransform);
        }
    }
 
    const bool hasRotation = !qFuzzyIsNull(rotation());
    const bool hasScale = !qFuzzyCompare(scale(), 1);
    if (hasScale || hasRotation) {
        QPointF tp = computeTransformOrigin();
        sceneTransform.translate(tp.x(), tp.y());
        if (hasScale)
            sceneTransform.scale(scale(), scale());
        if (hasRotation)
            sceneTransform.rotate(rotation(), 0, 0, 1);
        sceneTransform.translate(-tp.x(), -tp.y());
    }
 
    const QVector3D origin(sceneTransform.map(QPointF(0, 0)));
    const QVector3D right = QVector3D(sceneTransform.map(QPointF(1, 0))) - origin;
    const QVector3D top = QVector3D(sceneTransform.map(QPointF(0, 1))) - origin;
 
    wantBackYFlipped = right.x() < 0;
    wantBackXFlipped = top.y() < 0;
 
    const QQuickFlipable::Side newSide =
        QVector3D::crossProduct(top, right).z() > 0 ? QQuickFlipable::Back : QQuickFlipable::Front;
 
    if (newSide != current) {
        current = newSide;
        if (current == QQuickFlipable::Back && back)
            setBackTransform();
        if (front) {
            front->setOpacity((current==QQuickFlipable::Front)?1.:0.);
            front->setEnabled((current==QQuickFlipable::Front)?true:false);
        }
        if (back) {
            back->setOpacity((current==QQuickFlipable::Back)?1.:0.);
            back->setEnabled((current==QQuickFlipable::Back)?true:false);
        }
        emit q->sideChanged();
    }
}
 
/* Depends on the width/height of the back item, and so needs reevaulating
   if those change.
*/
void QQuickFlipablePrivate::setBackTransform()
{
    QTransform mat;
    mat.translate(back->width()/2,back->height()/2);
    if (back->width() && wantBackYFlipped)
        mat.rotate(180, Qt::YAxis);
    if (back->height() && wantBackXFlipped)
        mat.rotate(180, Qt::XAxis);
    mat.translate(-back->width()/2,-back->height()/2);
 
    if (backTransform)
        backTransform->setTransform(mat);
}
 
QT_END_NAMESPACE
 
#include "qquickflipable.moc"
#include "moc_qquickflipable_p.cpp"