#ifndef adwaitatransitionwidget_h
#define adwaitatransitionwidget_h
//////////////////////////////////////////////////////////////////////////////
// adwaitatransitionwidget.h
// stores event filters and maps widgets to transitions for transitions
// -------------------
//
// Copyright (c) 2009 Hugo Pereira Da Costa <hugo.pereira@free.fr>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//////////////////////////////////////////////////////////////////////////////

#include "adwaitaanimation.h"
#include "adwaita.h"

#include <QWidget>

#include <cmath>

namespace Adwaita
{

    //* temporary widget used to perform smooth transition between one widget state and another
    class TransitionWidget: public QWidget
    {

        Q_OBJECT

        //* declare opacity property
        Q_PROPERTY( qreal opacity READ opacity WRITE setOpacity )

        public:

        //* shortcut to painter
        typedef WeakPointer<TransitionWidget> Pointer;

        //* constructor
        TransitionWidget( QWidget* parent, int duration );

        //* destructor
        virtual ~TransitionWidget( void ) = default;

        //*@name flags
        //@{
        enum Flag
        {
            None = 0,
            GrabFromWindow = 1<<0,
            Transparent = 1<<1,
            PaintOnWidget = 1<<2
        };

        Q_DECLARE_FLAGS(Flags, Flag)

        void setFlags( Flags value )
        { _flags = value; }

        void setFlag( Flag flag, bool value = true )
        {
            if( value ) _flags |= flag;
            else _flags &= (~flag);
        }

        bool testFlag( Flag flag ) const
        { return _flags.testFlag( flag ); }

        //@}

        //* duration
        void setDuration( int duration )
        {
            if( _animation )
            { _animation.data()->setDuration( duration ); }
        }

        //* duration
        int duration( void ) const
        { return ( _animation ) ? _animation.data()->duration() : 0; }

        //* steps
        static void setSteps( int value )
        { _steps = value; }

        //*@name opacity
        //@{

        virtual qreal opacity( void ) const
        { return _opacity; }

        virtual void setOpacity( qreal value )
        {
            value = digitize( value );
            if( _opacity == value ) return;
            _opacity = value;
            update();
        }

        //@}

        //@name pixmaps handling
        //@{

        //* start
        void resetStartPixmap( void )
        { setStartPixmap( QPixmap() ); }

        //* start
        void setStartPixmap( QPixmap pixmap )
        { _startPixmap = pixmap; }

        //* start
        const QPixmap& startPixmap( void ) const
        { return _startPixmap; }

        //* end
        void resetEndPixmap( void )
        { setEndPixmap( QPixmap() ); }

        //* end
        void setEndPixmap( QPixmap pixmap )
        {
            _endPixmap = pixmap;
            _currentPixmap = pixmap;
        }

        //* start
        const QPixmap& endPixmap( void ) const
        { return _endPixmap; }

        //* current
        const QPixmap& currentPixmap( void ) const
        { return _currentPixmap; }

        //@}

        //* grap pixmap
        QPixmap grab( QWidget* = 0, QRect = QRect() );

        //* true if animated
        virtual bool isAnimated( void ) const
        { return _animation.data()->isRunning(); }

        //* end animation
        virtual void endAnimation( void )
        { if( _animation.data()->isRunning() ) _animation.data()->stop(); }

        //* animate transition
        virtual void animate( void )
        {
            if( _animation.data()->isRunning() ) _animation.data()->stop();
            _animation.data()->start();
        }

        //* true if paint is enabled
        static bool paintEnabled( void );

        protected:

        //* generic event filter
        virtual bool event( QEvent* );

        //* paint event
        virtual void paintEvent( QPaintEvent* );

        //* grab widget background
        /*!
        Background is not rendered properly using QWidget::render.
        Use home-made grabber instead. This is directly inspired from bespin.
        Copyright (C) 2007 Thomas Luebking <thomas.luebking@web.de>
        */
        virtual void grabBackground( QPixmap&, QWidget*, QRect& ) const;

        //* grab widget
        virtual void grabWidget( QPixmap&, QWidget*, QRect& ) const;

        //* fade pixmap
        virtual void fade( const QPixmap& source, QPixmap& target, qreal opacity, const QRect& ) const;

        //* apply step
        virtual qreal digitize( const qreal& value ) const
        {
            if( _steps > 0 ) return std::floor( value*_steps )/_steps;
            else return value;
        }

        private:

        //* Flags
        Flags _flags = None;

        //* paint enabled
        static bool _paintEnabled;

        //* internal transition animation
        Animation::Pointer _animation;

        //* animation starting pixmap
        QPixmap _startPixmap;

        //* animation starting pixmap
        QPixmap _localStartPixmap;

        //* animation starting pixmap
        QPixmap _endPixmap;

        //* current pixmap
        QPixmap _currentPixmap;

        //* current state opacity
        qreal _opacity = 0;

        //* steps
        static int _steps;

    };

}

#endif