[haiku-commits] r35958 - in haiku/trunk: headers/os/interface headers/os/support src/kits/interface

  • From: superstippi@xxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Fri, 26 Mar 2010 18:20:12 +0100 (CET)

Author: stippi
Date: 2010-03-26 18:20:11 +0100 (Fri, 26 Mar 2010)
New Revision: 35958
Changeset: http://dev.haiku-os.org/changeset/35958/haiku

Modified:
   haiku/trunk/headers/os/interface/AffineTransform.h
   haiku/trunk/headers/os/support/TypeConstants.h
   haiku/trunk/src/kits/interface/AffineTransform.cpp
Log:
Rewrote BAffineTransform to not be based on agg::trans_affine, which was pulling
in the AGG header. Reused the AGG code were applicable and implemented a lot
more features. The Multiply and PreMultiply meaning is reversed with respect to
AGG, but follows the mathematical meaning. Added type_code
B_AFFINE_TRANSFORM_TYPE to TypeConstants.h and let BAffineTransform derive from
BFlattenable.


Modified: haiku/trunk/headers/os/interface/AffineTransform.h
===================================================================
--- haiku/trunk/headers/os/interface/AffineTransform.h  2010-03-26 12:31:46 UTC 
(rev 35957)
+++ haiku/trunk/headers/os/interface/AffineTransform.h  2010-03-26 17:20:11 UTC 
(rev 35958)
@@ -4,126 +4,393 @@
  *
  * Authors:
  *             Stephen Deken, stephen.deken@xxxxxxxxx
+ *             Stephan Aßmus <superstippi@xxxxxx>
  */
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@xxxxxxxxxxxxx
+//          mcseemagg@xxxxxxxxx
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
 #ifndef _AFFINE_TRANSFORM_H
 #define _AFFINE_TRANSFORM_H
 
-#include <InterfaceDefs.h>
 
-#include <agg_trans_affine.h>
+#include <Flattenable.h>
+#include <Point.h>
 
-class BPoint;
+#include <math.h>
 
-namespace BPrivate {
 
-class BAffineTransform {
+class BAffineTransform : public BFlattenable {
 public:
+
+       static  const double                    kDefaultEpsilon = 1e-14;
+
+public:
                                                                        
BAffineTransform();
+                                                                       
BAffineTransform(double sx, double shy,
+                                                                               
double shx, double sy, double tx,
+                                                                               
double ty);
                                                                        
BAffineTransform(
                                                                                
const BAffineTransform& copyFrom);
-               virtual                                         
~BAffineTransform();
+       virtual                                                 
~BAffineTransform();
 
-               virtual BAffineTransform&       operator=(
-                                                                               
const BAffineTransform& copyFrom);
+       // BFlattenable interface
+       virtual bool                                    IsFixedSize() const;
+       virtual type_code                               TypeCode() const;
+       virtual ssize_t                                 FlattenedSize() const;
+       virtual status_t                                Flatten(void* buffer,
+                                                                               
ssize_t size) const;
+       virtual status_t                                Unflatten(type_code 
code,
+                                                                               
const void* buffer, ssize_t size);
 
-               virtual bool                            operator==(
-                                                                               
const BAffineTransform& other) const;
-               virtual bool                            operator!=(
-                                                                               
const BAffineTransform& other) const;
+       // Construction
+       static  BAffineTransform                AffineTranslation(double x, 
double y);
+       static  BAffineTransform                AffineRotation(double angle);
+       static  BAffineTransform                AffineScaling(double x, double 
y);
+       static  BAffineTransform                AffineScaling(double scale);
+       static  BAffineTransform                AffineShearing(double x, double 
y);
 
-       // Callbacks
-               virtual void                            TransformationChanged() 
const;
-
        // Application
-                               BPoint                          Apply(const 
BPoint& point) const;
-                               void                            Apply(BPoint* 
point) const;
-                               void                            Apply(BPoint* 
points, uint32 count) const;
+       inline  void                                    Apply(double* x, 
double* y) const;
+       inline  void                                    ApplyInverse(double* x, 
double* y) const;
 
-       // Rotation
-                               void                            Rotate(float 
angle);
-                               void                            Rotate(const 
BPoint& center, float angle);
-                               BAffineTransform&       RotateBySelf(float 
angle);
-                               BAffineTransform&       RotateBySelf(const 
BPoint& center, 
-                                                                               
float angle);
-                               BAffineTransform        RotateByCopy(float 
angle) const;
-                               BAffineTransform        RotateByCopy(const 
BPoint& center,
-                                                                               
float angle) const;
+                       BPoint                                  Apply(const 
BPoint& point) const;
+                       BPoint                                  
ApplyInverse(const BPoint& point) const;
 
+                       void                                    Apply(BPoint* 
point) const;
+                       void                                    
ApplyInverse(BPoint* point) const;
+
+                       void                                    Apply(BPoint* 
points, uint32 count) const;
+                       void                                    
ApplyInverse(BPoint* points,
+                                                                               
uint32 count) const;
+
        // Translation
-                               void                            Translate(float 
deltaX, float deltaY);
-                               void                            Translate(const 
BPoint& delta);
-                               BAffineTransform&       TranslateBySelf(float 
deltaX,
-                                                                               
float deltaY);
-                               BAffineTransform&       TranslateBySelf(const 
BPoint& delta);
-                               BAffineTransform        TranslateByCopy(float 
deltaX,
-                                                                               
float deltaY) const;
-                               BAffineTransform        TranslateByCopy(const 
BPoint& delta) const;
+       inline  const BAffineTransform& TranslateBy(double x, double y);
+                       const BAffineTransform& TranslateBy(const BPoint& 
delta);
 
+                       BAffineTransform                TranslateByCopy(double 
x, double y) const;
+                       BAffineTransform                TranslateByCopy(const 
BPoint& delta) const;
+
+       // Rotation
+       inline  const BAffineTransform& RotateBy(double angle);
+                       const BAffineTransform& RotateBy(const BPoint& center,
+                                                                               
double angle);
+
+                       BAffineTransform                RotateByCopy(double 
angle) const;
+                       BAffineTransform                RotateByCopy(const 
BPoint& center,
+                                                                               
double angle) const;
+
        // Scaling
-                               void                            Scale(float 
scale);
-                               void                            Scale(const 
BPoint& center, float scale);
-                               void                            Scale(float 
scaleX, float scaleY);
-                               void                            Scale(const 
BPoint& center, float scaleX,
-                                                                               
float scaleY);
-                               void                            Scale(const 
BPoint& scale);
-                               void                            Scale(const 
BPoint& center,
+       inline  const BAffineTransform& ScaleBy(double scale);
+                       const BAffineTransform& ScaleBy(const BPoint& center,
+                                                                               
double scale);
+       inline  const BAffineTransform& ScaleBy(double x, double y);
+                       const BAffineTransform& ScaleBy(const BPoint& center, 
double x,
+                                                                               
double y);
+                       const BAffineTransform& ScaleBy(const BPoint& scale);
+                       const BAffineTransform& ScaleBy(const BPoint& center,
                                                                                
const BPoint& scale);
-                               BAffineTransform&       ScaleBySelf(float 
scale);
-                               BAffineTransform&       ScaleBySelf(const 
BPoint& center,
-                                                                               
float scale);
-                               BAffineTransform&       ScaleBySelf(float 
scaleX, float scaleY);
-                               BAffineTransform&       ScaleBySelf(const 
BPoint& center,
-                                                                               
float scaleX, float scaleY);
-                               BAffineTransform&       ScaleBySelf(const 
BPoint& scale);
-                               BAffineTransform&       ScaleBySelf(const 
BPoint& center,
-                                                                               
const BPoint& scale);
-                               BAffineTransform        ScaleByCopy(float 
scale) const;
-                               BAffineTransform        ScaleByCopy(const 
BPoint& center,
-                                                                               
float scale) const;
-                               BAffineTransform        ScaleByCopy(float 
scaleX,
-                                                                               
float scaleY) const;
-                               BAffineTransform        ScaleByCopy(const 
BPoint& center,
-                                                                               
float scaleX, float scaleY) const;
-                               BAffineTransform        ScaleByCopy(const 
BPoint& scale) const;
-                               BAffineTransform        ScaleByCopy(const 
BPoint& center,
+
+                       BAffineTransform                ScaleByCopy(double 
scale) const;
+                       BAffineTransform                ScaleByCopy(const 
BPoint& center,
+                                                                               
double scale) const;
+                       BAffineTransform                ScaleByCopy(double x, 
double y) const;
+                       BAffineTransform                ScaleByCopy(const 
BPoint& center,
+                                                                               
double x, double y) const;
+                       BAffineTransform                ScaleByCopy(const 
BPoint& scale) const;
+                       BAffineTransform                ScaleByCopy(const 
BPoint& center,
                                                                                
const BPoint& scale) const;
 
        // Shearing
-                               void                            Shear(float 
shearX, float shearY);
-                               void                            Shear(const 
BPoint& center, float shearX,
-                                                                               
float shearY);
-                               void                            Shear(const 
BPoint& shear);
-                               void                            Shear(const 
BPoint& center,
+       inline  const BAffineTransform& ShearBy(double x, double y);
+                       const BAffineTransform& ShearBy(const BPoint& center, 
double x,
+                                                                               
double y);
+                       const BAffineTransform& ShearBy(const BPoint& shear);
+                       const BAffineTransform& ShearBy(const BPoint& center,
                                                                                
const BPoint& shear);
 
-                               BAffineTransform&       ShearBySelf(float 
shearX, float shearY);
-                               BAffineTransform&       ShearBySelf(const 
BPoint& center,
-                                                                               
float shearX, float shearY);
-                               BAffineTransform&       ShearBySelf(const 
BPoint& shear);
-                               BAffineTransform&       ShearBySelf(const 
BPoint& center,
-                                                                               
const BPoint& shear);
-                               BAffineTransform        ShearByCopy(float 
shearX,
-                                                                               
float shearY) const;
-                               BAffineTransform        ShearByCopy(const 
BPoint& center,
-                                                                               
float shearX, float shearY) const;
-                               BAffineTransform        ShearByCopy(const 
BPoint& shear) const;
-                               BAffineTransform        ShearByCopy(const 
BPoint& center,
+                       BAffineTransform                ShearByCopy(double x, 
double y) const;
+                       BAffineTransform                ShearByCopy(const 
BPoint& center,
+                                                                               
double x, double y) const;
+                       BAffineTransform                ShearByCopy(const 
BPoint& shear) const;
+                       BAffineTransform                ShearByCopy(const 
BPoint& center,
                                                                                
const BPoint& shear) const;
 
-private:
-                               void                            _Rotate(float 
angle);
-                               void                            _Scale(float 
scaleX, float scaleY);
-                               void                            
_Translate(float deltaX, float deltaY);
-                               void                            _Shear(float 
shearX, float shearY);
+       // Multiplication
+       inline  const BAffineTransform& Multiply(const BAffineTransform& other);
+                       const BAffineTransform& PreMultiply(const 
BAffineTransform& other);
+       inline  const BAffineTransform& MultiplyInverse(
+                                                                               
const BAffineTransform& other);
+       inline  const BAffineTransform& PreMultiplyInverse(
+                                                                               
const BAffineTransform& other);
 
-                               void                            
_TransformPoint(BPoint& point) const;
+       // Operators
+       inline  BAffineTransform&               operator=(
+                                                                               
const BAffineTransform& copyFrom);
 
-private:
-                               agg::trans_affine       fTransformMatrix;
+       inline  bool                                    operator==(
+                                                                               
const BAffineTransform& other) const;
+       inline  bool                                    operator!=(
+                                                                               
const BAffineTransform& other) const;
+
+       inline  const BAffineTransform& operator*=(const BAffineTransform& 
other);
+       inline  const BAffineTransform& operator/=(const BAffineTransform& 
other);
+
+       inline  BAffineTransform                operator*(
+                                                                               
const BAffineTransform& other) const;
+       inline  BAffineTransform                operator/(
+                                                                               
const BAffineTransform& other) const;
+
+       inline  BAffineTransform                operator~() const;
+
+       // Utility
+                       bool                                    IsValid(double 
epsilon
+                                                                               
= kDefaultEpsilon) const;
+                       bool                                    
IsIdentity(double epsilon
+                                                                               
= kDefaultEpsilon) const;
+                       bool                                    IsEqual(const 
BAffineTransform& other,
+                                                                               
double epsilon
+                                                                               
        = kDefaultEpsilon) const;
+
+                       const BAffineTransform& Invert();
+                       const BAffineTransform& FlipX();
+                       const BAffineTransform& FlipY();
+                       const BAffineTransform& Reset();
+
+       inline  double                                  Determinant() const;
+       inline  double                                  InverseDeterminant() 
const;
+                       void                                    
GetTranslation(double* tx,
+                                                                               
double* ty) const;
+                       double                                  Rotation() 
const;
+                       double                                  Scale() const;
+                       void                                    
GetScale(double* sx, double* sy) const;
+                       void                                    
GetScaleAbs(double* sx,
+                                                                               
double* sy) const;
+                       bool                                    
GetAffineParameters(double* translationX,
+                                                                               
double* translationY, double* rotation,
+                                                                               
double* scaleX, double* scaleY,
+                                                                               
double* shearX, double* shearY) const;
+
+public:
+                       double                                  sx;
+                       double                                  shy;
+                       double                                  shx;
+                       double                                  sy;
+                       double                                  tx;
+                       double                                  ty;
 };
 
-} // namespace BPrivate
 
-using namespace BPrivate;
+// #pragma mark - inline methods
 
+
+inline void
+BAffineTransform::Apply(double* x, double* y) const
+{
+       register double tmp = *x;
+       *x = tmp * sx + *y * shx + tx;
+       *y = tmp * shy + *y * sy + ty;
+}
+
+
+inline void
+BAffineTransform::ApplyInverse(double* x, double* y) const
+{
+       register double d = InverseDeterminant();
+       register double a = (*x - tx) * d;
+       register double b = (*y - ty) * d;
+       *x = a * sy - b * shx;
+       *y = b * sx - a * shy;
+}
+
+
+// #pragma mark -
+
+
+inline const BAffineTransform&
+BAffineTransform::TranslateBy(double x, double y)
+{
+       tx += x;
+       ty += y;
+       return *this;
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::RotateBy(double angle)
+{
+       double ca = cos(angle);
+       double sa = sin(angle);
+       double t0 = sx * ca - shy * sa;
+       double t2 = shx * ca - sy * sa;
+       double t4 = tx * ca - ty * sa;
+       shy = sx * sa + shy * ca;
+       sy = shx * sa + sy * ca;
+       ty = tx * sa + ty * ca;
+       sx = t0;
+       shx = t2;
+       tx = t4;
+       return *this;
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::ScaleBy(double x, double y)
+{
+       double mm0 = x;
+               // Possible hint for the optimizer
+       double mm3 = y;
+       sx *= mm0;
+       shx *= mm0;
+       tx *= mm0;
+       shy *= mm3;
+       sy *= mm3;
+       ty *= mm3;
+       return *this;
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::ScaleBy(double s)
+{
+       double m = s;
+               // Possible hint for the optimizer
+       sx *= m;
+       shx *= m;
+       tx *= m;
+       shy *= m;
+       sy *= m;
+       ty *= m;
+       return *this;
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::ShearBy(double x, double y)
+{
+       BAffineTransform shearTransform = AffineShearing(x, y);
+       return PreMultiply(shearTransform);
+}
+
+
+// #pragma mark -
+
+
+inline const BAffineTransform&
+BAffineTransform::Multiply(const BAffineTransform& other)
+{
+       BAffineTransform t(other);
+       return *this = t.PreMultiply(*this);
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::MultiplyInverse(const BAffineTransform& other)
+{
+       BAffineTransform t(other);
+       t.Invert();
+       return Multiply(t);
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::PreMultiplyInverse(const BAffineTransform& other)
+{
+       BAffineTransform t(other);
+       t.Invert();
+       return *this = t.Multiply(*this);
+}
+
+
+// #pragma mark -
+
+
+inline BAffineTransform&
+BAffineTransform::operator=(const BAffineTransform& other)
+{
+       sx = other.sx;
+       shy = other.shy;
+       shx = other.shx;
+       sy = other.sy;
+       tx = other.tx;
+       ty = other.ty;
+       return *this;
+}
+
+inline bool
+BAffineTransform::operator==(const BAffineTransform& other) const
+{
+       return IsEqual(other);
+}
+
+inline bool
+BAffineTransform::operator!=(const BAffineTransform& other) const
+{
+       return !IsEqual(other);
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::operator*=(const BAffineTransform& other)
+{
+       return Multiply(other);
+}
+
+
+inline const BAffineTransform&
+BAffineTransform::operator/=(const BAffineTransform& other)
+{
+       return MultiplyInverse(other);
+}
+
+
+inline BAffineTransform
+BAffineTransform::operator*(const BAffineTransform& other) const
+{
+       return BAffineTransform(*this).Multiply(other);
+}
+
+
+inline BAffineTransform
+BAffineTransform::operator/(const BAffineTransform& other) const
+{
+       return BAffineTransform(*this).MultiplyInverse(other);
+}
+
+
+inline BAffineTransform
+BAffineTransform::operator~() const
+{
+       BAffineTransform result(*this);
+       return result.Invert();
+}
+
+
+// #pragma mark -
+
+
+inline double
+BAffineTransform::Determinant() const
+{
+       return sx * sy - shy * shx;
+}
+
+
+inline double
+BAffineTransform::InverseDeterminant() const
+{
+       return 1.0 / (sx * sy - shy * shx);
+}
+
+
 #endif // _AFFINE_TRANSFORM_H

Modified: haiku/trunk/headers/os/support/TypeConstants.h
===================================================================
--- haiku/trunk/headers/os/support/TypeConstants.h      2010-03-26 12:31:46 UTC 
(rev 35957)
+++ haiku/trunk/headers/os/support/TypeConstants.h      2010-03-26 17:20:11 UTC 
(rev 35958)
@@ -13,6 +13,7 @@
 
 
 enum {
+       B_AFFINE_TRANSFORM_TYPE                 = 'AMTX',
        B_ANY_TYPE                                              = 'ANYT',
        B_ATOM_TYPE                                             = 'ATOM',
        B_ATOMREF_TYPE                                  = 'ATMR',
@@ -64,7 +65,7 @@
 // System-wide MIME types for handling URL's
 
 extern const char *B_URL_HTTP;                 // application/x-vnd.Be.URL.http
-extern const char *B_URL_HTTPS;                // 
application/x-vnd.Be.URL.https
+extern const char *B_URL_HTTPS;        // application/x-vnd.Be.URL.https
 extern const char *B_URL_FTP;          // application/x-vnd.Be.URL.ftp
 extern const char *B_URL_GOPHER;       // application/x-vnd.Be.URL.gopher
 extern const char *B_URL_MAILTO;       // application/x-vnd.Be.URL.mailto

Modified: haiku/trunk/src/kits/interface/AffineTransform.cpp
===================================================================
--- haiku/trunk/src/kits/interface/AffineTransform.cpp  2010-03-26 12:31:46 UTC 
(rev 35957)
+++ haiku/trunk/src/kits/interface/AffineTransform.cpp  2010-03-26 17:20:11 UTC 
(rev 35958)
@@ -4,178 +4,255 @@
  *
  * Authors:
  *             Stephen Deken, stephen.deken@xxxxxxxxx
+ *             Stephan Aßmus <superstippi@xxxxxx>
  */
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@xxxxxxxxxxxxx
+//          mcseemagg@xxxxxxxxx
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
 
 #include <AffineTransform.h>
-#include <Point.h>
 
+#include <TypeConstants.h>
 
+
 BAffineTransform::BAffineTransform()
        :
-       fTransformMatrix()
+       sx(1.0),
+       shy(0.0),
+       shx(0.0),
+       sy(1.0),
+       tx(0.0),
+       ty(0.0)
 {
 }
 
 
-BAffineTransform::BAffineTransform(const BAffineTransform& copyFrom)
+BAffineTransform::BAffineTransform(double sx, double shy, double shx,
+               double sy, double tx, double ty)
        :
-       fTransformMatrix(copyFrom.fTransformMatrix)
+       sx(sx),
+       shy(shy),
+       shx(shx),
+       sy(sy),
+       tx(tx),
+       ty(ty)
 {
 }
 
 
-BAffineTransform::~BAffineTransform()
+BAffineTransform::BAffineTransform(const BAffineTransform& other)
+       :
+       sx(other.sx),
+       shy(other.shy),
+       shx(other.shx),
+       sy(other.sy),
+       tx(other.tx),
+       ty(other.ty)
 {
 }
 
 
-BAffineTransform&
-BAffineTransform::operator=(const BAffineTransform& copyFrom)
+BAffineTransform::~BAffineTransform()
 {
-       if (copyFrom != *this) {
-               fTransformMatrix.reset();
-               fTransformMatrix.multiply(copyFrom.fTransformMatrix);
-               TransformationChanged();
-       }
-       return *this;
 }
 
 
+// #pragma mark -
+
+
 bool
-BAffineTransform::operator==(const BAffineTransform& other) const
+BAffineTransform::IsFixedSize() const
 {
-       return fTransformMatrix == other.fTransformMatrix;
+       return true;
 }
 
 
-bool
-BAffineTransform::operator!=(const BAffineTransform& other) const
+type_code
+BAffineTransform::TypeCode() const
 {
-       return fTransformMatrix != other.fTransformMatrix;
+       return B_AFFINE_TRANSFORM_TYPE;
 }
 
 
-void
-BAffineTransform::TransformationChanged() const
+ssize_t
+BAffineTransform::FlattenedSize() const
 {
-       // default implementation does nothing
+       return 6 * sizeof(double);
 }
 
 
-BPoint
-BAffineTransform::Apply(const BPoint& point) const
+status_t
+BAffineTransform::Flatten(void* _buffer, ssize_t size) const
 {
-       BPoint result(point);
-       _TransformPoint(result);
-       return result;
+       if (_buffer == NULL || size < FlattenedSize())
+               return B_BAD_VALUE;
+
+       double* buffer = reinterpret_cast<double*>(_buffer);
+
+       buffer[0] = sx;
+       buffer[1] = shy;
+       buffer[2] = shx;
+       buffer[3] = sy;
+       buffer[4] = tx;
+       buffer[5] = ty;
+
+       return B_OK;
 }
 
 
-void
-BAffineTransform::Apply(BPoint* point) const
+status_t
+BAffineTransform::Unflatten(type_code code, const void* _buffer, ssize_t size)
 {
-       if (point)
-               _TransformPoint(*point);
+       if (_buffer == NULL || size < FlattenedSize() || code != TypeCode())
+               return B_BAD_VALUE;
+
+       const double* buffer = reinterpret_cast<const double*>(_buffer);
+
+       sx = buffer[0];
+       shy = buffer[1];
+       shx = buffer[2];
+       sy = buffer[3];
+       tx = buffer[4];
+       ty = buffer[5];
+
+       return B_OK;
 }
 
 
-void
-BAffineTransform::Apply(BPoint* points, uint32 count) const
+// #pragma mark -
+
+
+/*static*/ BAffineTransform
+BAffineTransform::AffineTranslation(double x, double y)
 {
-       if (points) {
-               for (uint32 i = 0; i < count; ++i)
-                       _TransformPoint(points[i]);
-       }
+       return BAffineTransform(1.0, 0.0, 0.0, 1.0, x, y);
 }
 
 
-void
-BAffineTransform::Rotate(float angle)
+/*static*/ BAffineTransform
+BAffineTransform::AffineRotation(double angle)
 {
-       _Rotate(angle);
-       TransformationChanged();
+       return BAffineTransform(cos(angle), sin(angle), -sin(angle), cos(angle),
+               0.0, 0.0);
 }
 
 
-void
-BAffineTransform::Rotate(const BPoint& center, float angle)
+/*static*/ BAffineTransform
+BAffineTransform::AffineScaling(double x, double y)
 {
-       _Translate(-center.x, -center.y);
-       _Rotate(angle);
-       _Translate(center.x, center.y);
-       TransformationChanged();
+       return BAffineTransform(x, 0.0, 0.0, y, 0.0, 0.0);
 }
 
 
-BAffineTransform&
-BAffineTransform::RotateBySelf(float angle)
+/*static*/ BAffineTransform
+BAffineTransform::AffineScaling(double scale)
 {
-       Rotate(angle);
-       return *this;
+       return BAffineTransform(scale, 0.0, 0.0, scale, 0.0, 0.0);
 }
 
 
-BAffineTransform&
-BAffineTransform::RotateBySelf(const BPoint& center, float angle)
+/*static*/ BAffineTransform
+BAffineTransform::AffineShearing(double x, double y)
 {
-       Rotate(center, angle);
-       return *this;
+       return BAffineTransform(1.0, tan(y), tan(x), 1.0, 0.0, 0.0);
 }
 
 
-BAffineTransform
-BAffineTransform::RotateByCopy(float angle) const
+// #pragma mark -
+
+
+BPoint
+BAffineTransform::Apply(const BPoint& point) const
 {
-       BAffineTransform copy(*this);
-       copy.Rotate(angle);
-       return copy;
+       double x = point.x;
+       double y = point.y;
+       Apply(&x, &y);
+       return BPoint(x, y);
 }
 
 
-BAffineTransform
-BAffineTransform::RotateByCopy(const BPoint& center, float angle) const
+BPoint
+BAffineTransform::ApplyInverse(const BPoint& point) const
 {
-       BAffineTransform copy(*this);
-       copy.Rotate(center, angle);
-       return copy;
+       double x = point.x;
+       double y = point.y;
+       ApplyInverse(&x, &y);
+       return BPoint(x, y);
 }
 
 
 void
-BAffineTransform::Translate(float deltaX, float deltaY)
+BAffineTransform::Apply(BPoint* point) const
 {
-       _Translate(deltaX, deltaY);
-       TransformationChanged();
+       if (point == NULL)
+               return;
+       double x = point->x;
+       double y = point->y;
+       Apply(&x, &y);
+       point->x = x;
+       point->y = y;
 }
 
 
 void
-BAffineTransform::Translate(const BPoint& delta)
+BAffineTransform::ApplyInverse(BPoint* point) const
 {
-       Translate(delta.x, delta.y);
+       if (point == NULL)
+               return;
+       double x = point->x;
+       double y = point->y;
+       ApplyInverse(&x, &y);
+       point->x = x;
+       point->y = y;
 }
 
 
-BAffineTransform&
-BAffineTransform::TranslateBySelf(float deltaX, float deltaY)
+void
+BAffineTransform::Apply(BPoint* points, uint32 count) const
 {
-       Translate(deltaX, deltaY);
-       return *this;
+       if (points != NULL) {
+               for (uint32 i = 0; i < count; ++i)
+                       Apply(&points[i]);
+       }
 }
 
 
-BAffineTransform&
-BAffineTransform::TranslateBySelf(const BPoint& delta)
+void
+BAffineTransform::ApplyInverse(BPoint* points, uint32 count) const
 {
-       return TranslateBySelf(delta.x, delta.y);
+       if (points != NULL) {
+               for (uint32 i = 0; i < count; ++i)
+                       ApplyInverse(&points[i]);
+       }
 }
 
 
+// #pragma mark -
+
+
+const BAffineTransform&
+BAffineTransform::TranslateBy(const BPoint& delta)
+{
+       return TranslateBy(delta.x, delta.y);
+}
+
+
 BAffineTransform
-BAffineTransform::TranslateByCopy(float deltaX, float deltaY) const
+BAffineTransform::TranslateByCopy(double x, double y) const
 {
        BAffineTransform copy(*this);
-       copy.Translate(deltaX, deltaY);
+       copy.TranslateBy(x, y);
        return copy;
 }
 
@@ -187,287 +264,408 @@
 }
 
 
-void
-BAffineTransform::Scale(float scale)
+// #pragma mark -
+
+
+const BAffineTransform&
+BAffineTransform::RotateBy(const BPoint& center, double angle)
 {
-       Scale(scale, scale);
+       TranslateBy(-center.x, -center.y);
+       RotateBy(angle);
+       return TranslateBy(center.x, center.y);
 }
 
 
-void
-BAffineTransform::Scale(const BPoint& center, float scale)
+BAffineTransform
+BAffineTransform::RotateByCopy(double angle) const
 {
-       Scale(center, scale, scale);
+       BAffineTransform copy(*this);
+       copy.RotateBy(angle);
+       return copy;
 }
 
 
-void
-BAffineTransform::Scale(float scaleX, float scaleY)
+BAffineTransform
+BAffineTransform::RotateByCopy(const BPoint& center, double angle) const
 {
-       _Scale(scaleX, scaleY);
-       TransformationChanged();
+       BAffineTransform copy(*this);
+       copy.RotateBy(center, angle);
+       return copy;
 }
 
 
-void
-BAffineTransform::Scale(const BPoint& center, float scaleX, float scaleY)
+// #pragma mark -
+
+
+const BAffineTransform&
+BAffineTransform::ScaleBy(const BPoint& center, double scale)
 {
-       _Translate(-center.x, -center.y);
-       _Scale(scaleX, scaleY);
-       _Translate(center.x, center.y);
-       TransformationChanged();
+       return ScaleBy(center, scale, scale);
 }
 
 
-void
-BAffineTransform::Scale(const BPoint& scale)
+const BAffineTransform&
+BAffineTransform::ScaleBy(const BPoint& center, double x, double y)
 {
-       Scale(scale.x, scale.y);
+       TranslateBy(-center.x, -center.y);
+       ScaleBy(x, y);
+       return TranslateBy(center.x, center.y);
 }
 
 
-void
-BAffineTransform::Scale(const BPoint& center, const BPoint& scale)
+const BAffineTransform&
+BAffineTransform::ScaleBy(const BPoint& scale)
 {
-       Scale(center, scale.x, scale.y);
+       return ScaleBy(scale.x, scale.y);
 }
 
 
-BAffineTransform&
-BAffineTransform::ScaleBySelf(float scale)
+const BAffineTransform&
+BAffineTransform::ScaleBy(const BPoint& center, const BPoint& scale)
 {
-       return ScaleBySelf(scale, scale);
+       return ScaleBy(center, scale.x, scale.y);
 }
 
 
-BAffineTransform&
-BAffineTransform::ScaleBySelf(const BPoint& center, float scale)
+BAffineTransform
+BAffineTransform::ScaleByCopy(double scale) const
 {
-       return ScaleBySelf(center, scale, scale);
+       return ScaleByCopy(scale, scale);
 }
 
 
-BAffineTransform&
-BAffineTransform::ScaleBySelf(float scaleX, float scaleY)
+BAffineTransform
+BAffineTransform::ScaleByCopy(const BPoint& center, double scale) const
 {
-       Scale(scaleX, scaleY);
-       return *this;
+       return ScaleByCopy(center, scale, scale);
 }
 
 
-BAffineTransform&
-BAffineTransform::ScaleBySelf(const BPoint& center, float scaleX, float scaleY)
+BAffineTransform
+BAffineTransform::ScaleByCopy(double x, double y) const
 {
-       Scale(center, scaleX, scaleY);
-       return *this;
+       BAffineTransform copy(*this);
+       copy.ScaleBy(x, y);
+       return copy;
 }
 
 
-BAffineTransform&
-BAffineTransform::ScaleBySelf(const BPoint& scale)
+BAffineTransform
+BAffineTransform::ScaleByCopy(const BPoint& center, double x, double y) const
 {
-       return ScaleBySelf(scale.x, scale.y);
+       BAffineTransform copy(*this);
+       copy.ScaleBy(center, x, y);
+       return copy;
 }
 
 
-BAffineTransform&
-BAffineTransform::ScaleBySelf(const BPoint& center, const BPoint& scale)
+BAffineTransform
+BAffineTransform::ScaleByCopy(const BPoint& scale) const
 {
-       return ScaleBySelf(center, scale.x, scale.y);
+       return ScaleByCopy(scale.x, scale.y);
 }
 
 
 BAffineTransform
-BAffineTransform::ScaleByCopy(float scale) const
+BAffineTransform::ScaleByCopy(const BPoint& center, const BPoint& scale) const
 {
-       return ScaleByCopy(scale, scale);
+       return ScaleByCopy(center, scale.x, scale.y);

[... truncated: 393 lines follow ...]

Other related posts:

  • » [haiku-commits] r35958 - in haiku/trunk: headers/os/interface headers/os/support src/kits/interface - superstippi