/*
 * Copyright 2006, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 */

#ifndef CHANNEL_TRANSFORM_H
#define CHANNEL_TRANSFORM_H

#include "Transformable.h"

class ChannelTransform : public Transformable {
 public:
                                                                ChannelTransform();
                                                                ChannelTransform(const ChannelTransform& other);
        virtual                                         ~ChannelTransform();

        // ChannelTransform
        virtual void                            Update(bool deep = true) {}

                        void                            SetTransformation(const Transformable& other);

                        void                            SetTransformation(BPoint pivot,
                                                                                                  BPoint translation,
                                                                                                  double rotation,
                                                                                                  double xScale,
                                                                                                  double yScale);

                        void                            SetPivot(BPoint pivot);

        virtual void                            TranslateBy(BPoint offset);
        virtual void                            RotateBy(BPoint origin, double degrees);
                        void                            RotateBy(double degrees);

        virtual void                            ScaleBy(BPoint origin, double xScale,
                                                                        double yScale);
                        void                            ScaleBy(double xScale, double yScale);

                        void                            SetTranslationAndScale(BPoint offset,
                                                                                                           double xScale,
                                                                                                           double yScale);

        virtual void                            Reset();

        inline  BPoint                          Pivot() const
                                                                        { return fPivot; }
        inline  BPoint                          Translation() const
                                                                        { return fTranslation; }
        inline  double                          LocalRotation() const
                                                                        { return fRotation; }
        inline  double                          LocalXScale() const
                                                                        { return fXScale; }
        inline  double                          LocalYScale() const
                                                                        { return fYScale; }

                        ChannelTransform&       operator=(const ChannelTransform& other);

 private:
                        void                            _UpdateMatrix();

                        BPoint                          fPivot;
                        BPoint                          fTranslation;
                        double                          fRotation;
                        double                          fXScale;
                        double                          fYScale;
};

#endif // CHANNEL_TRANSFORM_H