QCustomStackedWidget.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
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.
 
Library: Widgets
File: QCustomStackedWidget
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/PopupInfo.h>
#include <NDEVR/ApplicationOptions.h>
#include <NDEVR/Buffer.h>
#include <QEasingCurve>
#include <QWidget>
#include <QPropertyAnimation>
#include <QPointer>
namespace NDEVR
{
    class ImageView;

    class NDEVR_WIDGETS_API QCustomStackedWidgetBase : public QWidget
    {
        Q_OBJECT
        Q_PROPERTY(double animation_percent READ animationPercent WRITE setAnimationPercent)
    public:
        enum StackAnimationDirection
        {
            e_left_to_right,  
            e_right_to_left,  
            e_top_to_bottom,  
            e_bottom_to_top,  
            e_automatic       
        };

        void setSpeed(int speed);
        void setAnimation(enum QEasingCurve::Type animationtype);
        void setVerticalMode(bool vertical = true);
        void setWrap(bool wrap);
        void setCustomPixmap(QPixmap* pixmap);
        QSize sizeHint() const override;
        QSize minimumSizeHint() const override;
        virtual void setCurrentIdx(uint04 current_index);
    protected:
        explicit QCustomStackedWidgetBase(QWidget *parent = nullptr);
        virtual ~QCustomStackedWidgetBase();
        void resizeEvent(QResizeEvent* event) override;
        void showEvent(QShowEvent* event) override;
        void setAnimationPercent(double animation_percent);
        double animationPercent() const { return m_animation_percent; }
        void paintEvent(QPaintEvent*) override;
        virtual void swapIndices(uint04 a, uint04 b);
        virtual void moveContent(uint04 from, uint04 to);
        virtual uint04 addWidget(QWidget* w);
        void insertWidget(uint04 index, QWidget *w);
        void removeWidget(QWidget* widget);
        void removeWidget(QWidget* widget, QWidget* slide_to_if_active);
        bool eventFilter(QObject* object, QEvent* event) override;
        uint04 activeIndex() const;
        QWidget* activeWidget() const;
        QWidget* currentWidget() const;
        QWidget* widget(uint04 index) const;
        uint04 indexOf(QWidget* widget) const;
        uint04 currentIndex() const { return m_current_index; }
        uint04 count() const;
        virtual void slideInNext();
        virtual void slideInPrev();
        virtual void slideInIdx(uint04 idx, PopupInfo origin_rect, int delay_time = 0, enum StackAnimationDirection direction = e_automatic);
        virtual void slideInIdx(uint04 idx, int delay_time = 0, enum StackAnimationDirection direction = e_automatic);
        virtual void slideInIdx(uint04 idx, enum StackAnimationDirection direction);
        virtual void slideInAnimation(PopupInfo origin_rect, enum StackAnimationDirection direction = e_automatic, bool cache_in_image = false);
        virtual void slideInAnimation(enum StackAnimationDirection direction = e_automatic, bool cache_in_image = false);
        virtual void slideInWgt(QWidget* widget, enum StackAnimationDirection direction = e_automatic, bool force_slide = false);
    public:
        static ApplicationOption<sint04> default_stack_animation_speed; 
    signals:
        void animationFinished();
 
    protected slots:
        void childDestroyedSlot(QObject* widget);
        void animationDoneSlot();
 
    protected:
        int m_speed; 
        enum QEasingCurve::Type m_animationtype; 
        uint04 m_now; 
        uint04 m_next; 
        uint04 m_last; 
        int m_last_animation_time; 
        QPoint m_offset; 
        PopupInfo m_popup_info; 
 
        double m_animation_percent; 
        uint04 m_current_index; 
        Buffer<QWidget*> m_child_widgets; 
        QPointer<QPropertyAnimation> m_move_animation; 
        bool m_is_animating; 
        bool m_vertical; 
        bool m_wrap = false; 
    private:
        QPixmap* m_cached_resize_image_out; 
        QPixmap* m_cached_resize_image_in; 
        QPixmap* m_resize_image_in_blend; 
        QPixmap* m_custom_pixmap; 
    };

    class QCustomStackedWidget : public QCustomStackedWidgetBase
    {
    public:
        explicit QCustomStackedWidget(QWidget* parent = nullptr)
            : QCustomStackedWidgetBase(parent)
        {}

        virtual uint04 addWidget(QWidget* w) override
        {
            return QCustomStackedWidgetBase::addWidget(w);
        };

        virtual void slideInNext() override {
            QCustomStackedWidgetBase::slideInNext();
        }

        virtual void slideInPrev() override {
            QCustomStackedWidgetBase::slideInPrev();
        }

        void setCurrentIndex(uint04 idx)
        {
            QCustomStackedWidgetBase::setCurrentIdx(idx);
        }

        void slideInIdx(uint04 idx, PopupInfo origin_rect, int delay_time = 0, enum StackAnimationDirection direction = e_automatic) override
        {
            QCustomStackedWidgetBase::slideInIdx(idx, origin_rect, delay_time, direction);
        }

        void slideInIdx(uint04 idx, int delay_time = 0, enum StackAnimationDirection direction = e_automatic) override {
            QCustomStackedWidgetBase::slideInIdx(idx, delay_time, direction);
        }

        void slideInIdx(uint04 idx, enum StackAnimationDirection direction) override {
            QCustomStackedWidgetBase::slideInIdx(idx, direction);
        }

        void slideInAnimation(PopupInfo origin_rect, enum StackAnimationDirection direction = e_automatic, bool cache_in_image = false)override {
            QCustomStackedWidgetBase::slideInAnimation(origin_rect, direction, cache_in_image);
        }

        void slideInAnimation(enum StackAnimationDirection direction = e_automatic, bool cache_in_image = false) override {
            QCustomStackedWidgetBase::slideInAnimation(direction, cache_in_image);
        }

        void slideInWgt(QWidget* widget, enum StackAnimationDirection direction = e_automatic, bool force_slide = false) override {
            QCustomStackedWidgetBase::slideInWgt(widget, direction, force_slide);
        }

        void removeWidget(QWidget* widget)
        {
            QCustomStackedWidgetBase::removeWidget(widget);
        }

        void removeWidget(QWidget* widget, QWidget* slide_in)
        {
            QCustomStackedWidgetBase::removeWidget(widget, slide_in);
        }

        QWidget* widget(uint04 idx) const
        {
            return QCustomStackedWidgetBase::widget(idx);
        }

        void insertWidget(uint04 index, QWidget* w)
        {
            QCustomStackedWidgetBase::insertWidget(index, w);
        }

        void moveContent(uint04 from, uint04 to) override
        {
            QCustomStackedWidgetBase::moveContent(from, to);
        }

        void swapIndices(uint04 a, uint04 b) override
        {
            QCustomStackedWidgetBase::swapIndices(a, b);
        }

        uint04 activeIndex() const {
            return QCustomStackedWidgetBase::activeIndex();
        }

        QWidget* activeWidget() const {
            return QCustomStackedWidgetBase::activeWidget();
        }

        uint04 count() const {
            return QCustomStackedWidgetBase::count();
        }

        bool hasWidget(QWidget* widget) const
        {
            return IsValid(QCustomStackedWidgetBase::indexOf(widget));
        }

        uint04 currentIndex() const { return m_current_index; }
        uint04 indexOf(QWidget* widget) const { return QCustomStackedWidgetBase::indexOf(widget); }
        QWidget* currentWidget() const { return QCustomStackedWidgetBase::currentWidget(); }
    };
}