Revision control
++ // 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
++ // Qt-Security score:significant reason:default
++
++ #include "qquickflipable_p.h"
++ #include "qquickitem_p.h"
++ #include "qquicktranslate_p.h"
++
++ #include <QtQml/qqmlinfo.h>
++
++ #include <QtCore/qpointer.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;
++ };
++
++ /*!
++ \qmltype Flipable
++ \nativetype QQuickFlipable
++ \inqmlmodule QtQuick
++ \inherits Item
++ \ingroup qtquick-input
++ \ingroup qtquick-containers
++ \brief Provides a surface that can be flipped.
++
++ Flipable is an item that can be visibly "flipped" between its front and
++ back sides, like a card. It may used together with \l Rotation, \l State
++ and \l Transition types to produce a flipping effect.
++
++ The \l front and \l back properties are used to hold the items that are
++ shown respectively on the front and back sides of the flipable item.
++
++ \section1 Example Usage
++
++ The following example shows a Flipable item that flips whenever it is
++ clicked, rotating about the y-axis.
++
++ This flipable item has a \c flipped boolean property that is toggled
++ whenever the MouseArea within the flipable is clicked. When
++ \c flipped is true, the item changes to the "back" state; in this
++ state, the \c angle of the \l Rotation item is changed to 180
++ degrees to produce the flipping effect. When \c flipped is false, the
++ item reverts to the default state, in which the \c angle value is 0.
++
++ \snippet qml/flipable/flipable.qml 0
++
++ \image flipable.gif {Qt logo flipping between front and back sides
++ with rotation animation}
++
++ The \l Transition creates the animation that changes the angle over
++ four seconds. When the item changes between its "back" and
++ default states, the NumberAnimation animates the angle between
++ its old and new values.
++
++ See \l {Qt Quick States} for details on state changes and the default
++ state, and \l {Animation and Transitions in Qt Quick} for more information on how
++ animations work within transitions.
++
++ \sa {customitems/flipable}{UI Components: Flipable Example}
++ */
++ QQuickFlipable::QQuickFlipable(QQuickItem *parent)
++ : QQuickItem(*(new QQuickFlipablePrivate), parent)
++ {
++ }
++
++ QQuickFlipable::~QQuickFlipable()
++ {
++ }
++
++ /*!
++ \qmlproperty Item QtQuick::Flipable::front
++ \qmlproperty Item QtQuick::Flipable::back
++
++ The front and back sides of the flipable.
++ */
++
++ 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();
++ }
++
++ /*!
++ \qmlproperty enumeration QtQuick::Flipable::side
++
++ The side of the Flipable currently visible. Possible values are \c
++ Flipable.Front and \c Flipable.Back.
++ */
++ 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();
++ }
++
++ /*! \internal
++ Flipable must use the complete scene transform to correctly determine the
++ currently visible side.
++
++ It must also be independent of camera distance, in case the contents are
++ too wide: for rotation transforms we simply call QMatrix4x4::rotate(),
++ whereas QQuickRotation::applyTo(QMatrix4x4*) calls
++ QMatrix4x4::projectedRotate() which by default assumes the camera distance
++ is 1024 virtual pixels. So for example if contents inside Flipable are to
++ be flipped around the y axis, and are wider than 1024*2, some of the
++ rendering goes behind the "camera". That's expected for rendering (since we
++ didn't provide API to change camera distance), but not ok for deciding when
++ to flip.
++ */
++ 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"