AffineTransformCG.cpp [plain text]
#include "config.h"
#include "AffineTransform.h"
#if PLATFORM(CG)
#include "FloatConversion.h"
#include "FloatRect.h"
#include "IntRect.h"
#include <wtf/MathExtras.h>
namespace WebCore {
AffineTransform::AffineTransform()
{
m_transform = CGAffineTransformIdentity;
}
AffineTransform::AffineTransform(double a, double b, double c, double d, double tx, double ty)
{
m_transform = CGAffineTransformMake(narrowPrecisionToCGFloat(a),
narrowPrecisionToCGFloat(b),
narrowPrecisionToCGFloat(c),
narrowPrecisionToCGFloat(d),
narrowPrecisionToCGFloat(tx),
narrowPrecisionToCGFloat(ty));
}
AffineTransform::AffineTransform(CGAffineTransform t)
{
m_transform = t;
}
void AffineTransform::setMatrix(double a, double b, double c, double d, double tx, double ty)
{
m_transform = CGAffineTransformMake(narrowPrecisionToCGFloat(a),
narrowPrecisionToCGFloat(b),
narrowPrecisionToCGFloat(c),
narrowPrecisionToCGFloat(d),
narrowPrecisionToCGFloat(tx),
narrowPrecisionToCGFloat(ty));
}
void AffineTransform::map(double x, double y, double *x2, double *y2) const
{
CGPoint result = CGPointApplyAffineTransform(CGPointMake(narrowPrecisionToCGFloat(x), narrowPrecisionToCGFloat(y)), m_transform);
*x2 = result.x;
*y2 = result.y;
}
IntRect AffineTransform::mapRect(const IntRect &rect) const
{
return enclosingIntRect(CGRectApplyAffineTransform(CGRect(rect), m_transform));
}
FloatRect AffineTransform::mapRect(const FloatRect &rect) const
{
return FloatRect(CGRectApplyAffineTransform(CGRect(rect), m_transform));
}
bool AffineTransform::isIdentity() const
{
return CGAffineTransformIsIdentity(m_transform);
}
double AffineTransform::a() const
{
return m_transform.a;
}
void AffineTransform::setA(double a)
{
m_transform.a = narrowPrecisionToCGFloat(a);
}
double AffineTransform::b() const
{
return m_transform.b;
}
void AffineTransform::setB(double b)
{
m_transform.b = narrowPrecisionToCGFloat(b);
}
double AffineTransform::c() const
{
return m_transform.c;
}
void AffineTransform::setC(double c)
{
m_transform.c = narrowPrecisionToCGFloat(c);
}
double AffineTransform::d() const
{
return m_transform.d;
}
void AffineTransform::setD(double d)
{
m_transform.d = narrowPrecisionToCGFloat(d);
}
double AffineTransform::e() const
{
return m_transform.tx;
}
void AffineTransform::setE(double e)
{
m_transform.tx = narrowPrecisionToCGFloat(e);
}
double AffineTransform::f() const
{
return m_transform.ty;
}
void AffineTransform::setF(double f)
{
m_transform.ty = narrowPrecisionToCGFloat(f);
}
void AffineTransform::reset()
{
m_transform = CGAffineTransformIdentity;
}
AffineTransform &AffineTransform::scale(double sx, double sy)
{
m_transform = CGAffineTransformScale(m_transform, narrowPrecisionToCGFloat(sx), narrowPrecisionToCGFloat(sy));
return *this;
}
AffineTransform &AffineTransform::rotate(double d)
{
m_transform = CGAffineTransformRotate(m_transform, narrowPrecisionToCGFloat(deg2rad(d)));
return *this;
}
AffineTransform &AffineTransform::translate(double tx, double ty)
{
m_transform = CGAffineTransformTranslate(m_transform, narrowPrecisionToCGFloat(tx), narrowPrecisionToCGFloat(ty));
return *this;
}
AffineTransform &AffineTransform::shear(double sx, double sy)
{
CGAffineTransform shear = CGAffineTransformMake(1.0f, narrowPrecisionToCGFloat(sy), narrowPrecisionToCGFloat(sx), 1.0f, 0.0f, 0.0f);
m_transform = CGAffineTransformConcat(shear, m_transform);
return *this;
}
double AffineTransform::det() const
{
return m_transform.a * m_transform.d - m_transform.b * m_transform.c;
}
AffineTransform AffineTransform::inverse() const
{
if (isInvertible())
return AffineTransform(CGAffineTransformInvert(m_transform));
return AffineTransform();
}
AffineTransform::operator CGAffineTransform() const
{
return m_transform;
}
bool AffineTransform::operator== (const AffineTransform &m2) const
{
return CGAffineTransformEqualToTransform(m_transform, CGAffineTransform(m2));
}
AffineTransform &AffineTransform::operator*= (const AffineTransform &m2)
{
m_transform = CGAffineTransformConcat(m_transform, CGAffineTransform(m2));
return *this;
}
AffineTransform AffineTransform::operator* (const AffineTransform &m2)
{
return CGAffineTransformConcat(m_transform, CGAffineTransform(m2));
}
}
#endif // PLATFORM(CG)