/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QTRANSFORM_H

#define QTRANSFORM_H

#include <QtGui/qmatrix.h>

#include <QtGui/qpainterpath.h>

#include <QtGui/qpolygon.h>

#include <QtGui/qregion.h>

#include <QtGui/qwindowdefs.h>

#include <QtCore/qline.h>

#include <QtCore/qpoint.h>

#include <QtCore/qrect.h>

#if defined(Q_OS_VXWORKS) && defined(m_type)

#  undef m_type

#endif

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(Gui)

class QVariant;

class Q_GUI_EXPORT QTransform

{

    Q_ENUMS(TransformationType)

public:

    enum TransformationType {

        TxNone      = 0x00,

        TxTranslate = 0x01,

        TxScale     = 0x02,

        TxRotate    = 0x04,

        TxShear     = 0x08,

        TxProject   = 0x10

    };

    inline explicit QTransform(Qt::Initialization) : affine(Qt::Uninitialized) {}

    QTransform();

    QTransform(qreal h11, qreal h12, qreal h13,

               qreal h21, qreal h22, qreal h23,

               qreal h31, qreal h32, qreal h33 = 1.0);

    QTransform(qreal h11, qreal h12, qreal h21,

               qreal h22, qreal dx, qreal dy);

    explicit QTransform(const QMatrix &mtx);

    bool isAffine() const;

    bool isIdentity() const;

    bool isInvertible() const;

    bool isScaling() const;

    bool isRotating() const;

    bool isTranslating() const;

    TransformationType type() const;

    inline qreal determinant() const;

    qreal det() const;

    qreal m11() const;

    qreal m12() const;

    qreal m13() const;

    qreal m21() const;

    qreal m22() const;

    qreal m23() const;

    qreal m31() const;

    qreal m32() const;

    qreal m33() const;

    qreal dx() const;

    qreal dy() const;

    void setMatrix(qreal m11, qreal m12, qreal m13,

                   qreal m21, qreal m22, qreal m23,

                   qreal m31, qreal m32, qreal m33);

    QTransform inverted(bool *invertible = 0) const;

    QTransform adjoint() const;

    QTransform transposed() const;

    QTransform &translate(qreal dx, qreal dy);

    QTransform &scale(qreal sx, qreal sy);

    QTransform &shear(qreal sh, qreal sv);

    QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis);

    QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis);

    static bool squareToQuad(const QPolygonF &square, QTransform &result);

    static bool quadToSquare(const QPolygonF &quad, QTransform &result);

    static bool quadToQuad(const QPolygonF &one,

                           const QPolygonF &two,

                           QTransform &result);

    bool operator==(const QTransform &) const;

    bool operator!=(const QTransform &) const;

    QTransform &operator*=(const QTransform &);

    QTransform operator*(const QTransform &o) const;

    QTransform &operator=(const QTransform &);

    operator QVariant() const;

    void reset();

    QPoint       map(const QPoint &p) const;

    QPointF      map(const QPointF &p) const;

    QLine        map(const QLine &l) const;

    QLineF       map(const QLineF &l) const;

    QPolygonF    map(const QPolygonF &a) const;

    QPolygon     map(const QPolygon &a) const;

    QRegion      map(const QRegion &r) const;

    QPainterPath map(const QPainterPath &p) const;

    QPolygon     mapToPolygon(const QRect &r) const;

    QRect mapRect(const QRect &) const;

    QRectF mapRect(const QRectF &) const;

    void map(int x, int y, int *tx, int *ty) const;

    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;

    const QMatrix &toAffine() const;

    QTransform &operator*=(qreal div);

    QTransform &operator/=(qreal div);

    QTransform &operator+=(qreal div);

    QTransform &operator-=(qreal div);

    static QTransform fromTranslate(qreal dx, qreal dy);

    static QTransform fromScale(qreal dx, qreal dy);

private:

    inline QTransform(qreal h11, qreal h12, qreal h13,

                      qreal h21, qreal h22, qreal h23,

                      qreal h31, qreal h32, qreal h33, bool)

        : affine(h11, h12, h21, h22, h31, h32, true)

        , m_13(h13), m_23(h23), m_33(h33)

        , m_type(TxNone)

        , m_dirty(TxProject) {}

    inline QTransform(bool)

        : affine(true)

        , m_13(0), m_23(0), m_33(1)

        , m_type(TxNone)

        , m_dirty(TxNone) {}

    inline TransformationType inline_type() const;

    QMatrix affine;

    qreal   m_13;

    qreal   m_23;

    qreal   m_33;

    mutable uint m_type : 5;

    mutable uint m_dirty : 5;

    class Private;

    Private *d;

};

Q_DECLARE_TYPEINFO(QTransform, Q_MOVABLE_TYPE);

/******* inlines *****/

inline QTransform::TransformationType QTransform::inline_type() const

{

    if (m_dirty == TxNone)

        return static_cast<TransformationType>(m_type);

    return type();

}

inline bool QTransform::isAffine() const

{

    return inline_type() < TxProject;

}

inline bool QTransform::isIdentity() const

{

    return inline_type() == TxNone;

}

inline bool QTransform::isInvertible() const

{

    return !qFuzzyIsNull(determinant());

}

inline bool QTransform::isScaling() const

{

    return type() >= TxScale;

}

inline bool QTransform::isRotating() const

{

    return inline_type() >= TxRotate;

}

inline bool QTransform::isTranslating() const

{

    return inline_type() >= TxTranslate;

}

inline qreal QTransform::determinant() const

{

    return affine._m11*(m_33*affine._m22-affine._dy*m_23) -

        affine._m21*(m_33*affine._m12-affine._dy*m_13)+affine._dx*(m_23*affine._m12-affine._m22*m_13);

}

inline qreal QTransform::det() const

{

    return determinant();

}

inline qreal QTransform::m11() const

{

    return affine._m11;

}

inline qreal QTransform::m12() const

{

    return affine._m12;

}

inline qreal QTransform::m13() const

{

    return m_13;

}

inline qreal QTransform::m21() const

{

    return affine._m21;

}

inline qreal QTransform::m22() const

{

    return affine._m22;

}

inline qreal QTransform::m23() const

{

    return m_23;

}

inline qreal QTransform::m31() const

{

    return affine._dx;

}

inline qreal QTransform::m32() const

{

    return affine._dy;

}

inline qreal QTransform::m33() const

{

    return m_33;

}

inline qreal QTransform::dx() const

{

    return affine._dx;

}

inline qreal QTransform::dy() const

{

    return affine._dy;

}

inline QTransform &QTransform::operator*=(qreal num)

{

    if (num == 1.)

        return *this;

    affine._m11 *= num;

    affine._m12 *= num;

    m_13        *= num;

    affine._m21 *= num;

    affine._m22 *= num;

    m_23        *= num;

    affine._dx  *= num;

    affine._dy  *= num;

    m_33        *= num;

    if (m_dirty < TxScale)

        m_dirty = TxScale;

    return *this;

}

inline QTransform &QTransform::operator/=(qreal div)

{

    if (div == 0)

        return *this;

    div = 1/div;

    return operator*=(div);

}

inline QTransform &QTransform::operator+=(qreal num)

{

    if (num == 0)

        return *this;

    affine._m11 += num;

    affine._m12 += num;

    m_13        += num;

    affine._m21 += num;

    affine._m22 += num;

    m_23        += num;

    affine._dx  += num;

    affine._dy  += num;

    m_33        += num;

    m_dirty     = TxProject;

    return *this;

}

inline QTransform &QTransform::operator-=(qreal num)

{

    if (num == 0)

        return *this;

    affine._m11 -= num;

    affine._m12 -= num;

    m_13        -= num;

    affine._m21 -= num;

    affine._m22 -= num;

    m_23        -= num;

    affine._dx  -= num;

    affine._dy  -= num;

    m_33        -= num;

    m_dirty     = TxProject;

    return *this;

}

inline bool qFuzzyCompare(const QTransform& t1, const QTransform& t2)

{

    return qFuzzyCompare(t1.m11(), t2.m11())

        && qFuzzyCompare(t1.m12(), t2.m12())

        && qFuzzyCompare(t1.m13(), t2.m13())

        && qFuzzyCompare(t1.m21(), t2.m21())

        && qFuzzyCompare(t1.m22(), t2.m22())

        && qFuzzyCompare(t1.m23(), t2.m23())

        && qFuzzyCompare(t1.m31(), t2.m31())

        && qFuzzyCompare(t1.m32(), t2.m32())

        && qFuzzyCompare(t1.m33(), t2.m33());

}

/****** stream functions *******************/

#ifndef QT_NO_DATASTREAM

Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QTransform &);

Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QTransform &);

#endif

#ifndef QT_NO_DEBUG_STREAM

Q_GUI_EXPORT QDebug operator<<(QDebug, const QTransform &);

#endif

/****** end stream functions *******************/

// mathematical semantics

Q_GUI_EXPORT_INLINE QPoint operator*(const QPoint &p, const QTransform &m)

{ return m.map(p); }

Q_GUI_EXPORT_INLINE QPointF operator*(const QPointF &p, const QTransform &m)

{ return m.map(p); }

Q_GUI_EXPORT_INLINE QLineF operator*(const QLineF &l, const QTransform &m)

{ return m.map(l); }

Q_GUI_EXPORT_INLINE QLine operator*(const QLine &l, const QTransform &m)

{ return m.map(l); }

Q_GUI_EXPORT_INLINE QPolygon operator *(const QPolygon &a, const QTransform &m)

{ return m.map(a); }

Q_GUI_EXPORT_INLINE QPolygonF operator *(const QPolygonF &a, const QTransform &m)

{ return m.map(a); }

Q_GUI_EXPORT_INLINE QRegion operator *(const QRegion &r, const QTransform &m)

{ return m.map(r); }

Q_GUI_EXPORT_INLINE QPainterPath operator *(const QPainterPath &p, const QTransform &m)

{ return m.map(p); }

Q_GUI_EXPORT_INLINE QTransform operator *(const QTransform &a, qreal n)

{ QTransform t(a); t *= n; return t; }

Q_GUI_EXPORT_INLINE QTransform operator /(const QTransform &a, qreal n)

{ QTransform t(a); t /= n; return t; }

Q_GUI_EXPORT_INLINE QTransform operator +(const QTransform &a, qreal n)

{ QTransform t(a); t += n; return t; }

Q_GUI_EXPORT_INLINE QTransform operator -(const QTransform &a, qreal n)

{ QTransform t(a); t -= n; return t; }

QT_END_NAMESPACE

QT_END_HEADER

#endif