QCustomStackedWidget.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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;
 
    /**--------------------------------------------------------------------------------------------------
    \brief A base class for a series of widgets where all widgets occupy the same same and only one widget
        is shown at a time.
     **/
    class NDEVR_WIDGETS_API QCustomStackedWidgetBase : public QWidget
    {
        Q_OBJECT
        Q_PROPERTY(double animation_percent READ animationPercent WRITE setAnimationPercent)
    public:
        // This enumeration is used to define the animation direction
        enum StackAnimationDirection 
        {
            e_left_to_right,
            e_right_to_left,
            e_top_to_bottom,
            e_bottom_to_top,
            e_automatic
        };
        void setSpeed(int speed); // animation duration in milliseconds
        void setAnimation(enum QEasingCurve::Type animationtype); // check out the QEasingCurve documentation for different styles
        void setVerticalMode(bool vertical = true);
        void setWrap(bool wrap); // wrapping is related to slideInNext/Prev;it defines the behaviour when reaching last/first page
        void setCustomPixmap(QPixmap* pixmap);
    protected:
        // The Constructor and Destructor
        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;
        QSize sizeHint() const override;
        QSize minimumSizeHint() const override;
        QWidget* widget(uint04 index) const;
        
        uint04 indexOf(QWidget* widget) const;
 
        uint04 currentIndex() const { return m_current_index; }
        uint04 count() const;
        virtual void setCurrentIdx(uint04 current_index);
        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;//default time in milliseconds to animate a slide transition
    signals:
        // this is used for internal purposes in the class engine
        void animationFinished();
 
    protected slots:
        void childDestroyedSlot(QObject* widget);
        // this is used for internal purposes in the class engine
        void animationDoneSlot();
 
    protected:
        // this is used for internal purposes in the class engine
        
        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;
        //QGraphicsOpacityEffect* m_primary_image_view;
        //QGraphicsOpacityEffect* m_fade_out;
        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;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief The main class for a layout where all widgets occupy the same same and only one widget
        is shown at a time.
     **/
    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);
        }
        uint04 activeIndex() const {
            return QCustomStackedWidgetBase::activeIndex();
        }
        QWidget* activeWidget() const {
            return QCustomStackedWidgetBase::activeWidget();
        }
        uint04 count() const {
            return QCustomStackedWidgetBase::count();
        }
        bool hasWidget(QWidget* widget) const
        {
            return !IsInvalid(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(); }
    };
}