/*
 * Copyright 2005, Stephan Aßmus <superstippi@gmx.de>. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * A handy front-end to agg::trans_affine transformation matrix.
 *
 */


#ifndef TRANSFORMABLE_H
#define TRANSFORMABLE_H

#include <Archivable.h>
#include <Rect.h>

#include <agg_trans_affine.h>

class Transformable : public BArchivable,
                                          public agg::trans_affine {
 public:
                                                                Transformable();
                                                                Transformable(const Transformable& other);
                                                                Transformable(const BMessage* archive);
        virtual                                         ~Transformable();

                                                                // the BArchivable protocol
                                                                // stores matrix directly to message, deep is ignored
        virtual status_t                        Archive(BMessage* into, bool deep = true) const;

                        void                            StoreTo(double matrix[6]) const;
                        void                            LoadFrom(double matrix[6]);

                                                                // set to or combine with other matrix
                        void                            SetTransformable(const Transformable& other);
                        Transformable&          operator=(const agg::trans_affine& other);
                        Transformable&          operator=(const Transformable& other);
                        Transformable&          Multiply(const Transformable& other);
                        void                            Reset();

                        bool                            IsIdentity() const;
                        bool                            IsDilation() const;
//                      bool                            operator==(const Transformable& other) const;
//                      bool                            operator!=(const Transformable& other) const;

                                                                // transforms coordiantes
                        void                            Transform(double* x, double* y) const;
                        void                            Transform(BPoint* point) const;
                        BPoint                          Transform(const BPoint& point) const;

                        void                            InverseTransform(double* x, double* y) const;
                        void                            InverseTransform(BPoint* point) const;
                        BPoint                          InverseTransform(const BPoint& point) const;

                                                                // transforms the rectangle "bounds" and
                                                                // returns the *bounding box* of that
                        BRect                           TransformBounds(const BRect& bounds) const;

                        bool                            IsTranslationOnly() const;

                                                                // some convenience functions
        virtual void                            TranslateBy(BPoint offset);
        virtual void                            RotateBy(BPoint origin, double radians);
        virtual void                            ScaleBy(BPoint origin, double xScale, double yScale);
        virtual void                            ShearBy(BPoint origin, double xShear, double yShear);

        virtual void                            TransformationChanged() {}
};

#endif // TRANSFORMABLE_H