QCustomSplitter.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: QCustomSplitter
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/BaseValues.h>
#include <QStyle>
#include <QEvent>
#include <QSplitter>
namespace NDEVR
{
    class NDEVR_WIDGETS_API QCustomSplitter : public QSplitter
    {
        Q_OBJECT
    public:
        explicit QCustomSplitter(QWidget* parent = nullptr)
            : QSplitter(parent)
            , m_is_animating(false)
        {}

        explicit QCustomSplitter(Qt::Orientation orientation, QWidget* parent = nullptr)
            : QSplitter(orientation, parent)
            , m_is_animating(false)
        {}
        virtual ~QCustomSplitter()
        {};

        void setAnimating(bool animating)
        {
            m_is_animating = animating;
            if (!m_is_animating)
            {
                refreshSizes();
            }
        }

        fltp08 sizeMultiple()
        {
            sint08 total = 0;
            for (int i = 0; i < count(); i++)
            {
                total += (orientation() == Qt::Orientation::Horizontal) ? widget(i)->sizeHint().width() : widget(i)->sizeHint().height();
            }
            int our_size = availableSize();
            if (our_size == 0 || total == 0)
                return 1.0;
            return cast<fltp08>(total) / cast<fltp08>(our_size);
        }

        int availableSize() const
        {
            int available_size = orientation() == Qt::Orientation::Horizontal ? width() : height();
            available_size -= count() * style()->pixelMetric(QStyle::PixelMetric::PM_SplitterWidth, nullptr, this);
            return available_size;
        }

        sint04 sizeIfAdded(sint04 preferred_size, sint04 min_size, sint04 current_size) const
        {
            preferred_size = getMax(preferred_size, min_size);
            int available_size = availableSize();
 
            if (available_size == 0)
                return preferred_size;
            if (count() == 1)
                return available_size;
            sint08 total = 0;
            for (int i = 0; i < count(); i++)
            {
                total += (orientation() == Qt::Orientation::Horizontal) ? widget(i)->sizeHint().width() : widget(i)->sizeHint().height();
            }
            if (total <= 0)
                return available_size;
            fltp08 multiple = cast<fltp08>(available_size) / cast<fltp08>(total + preferred_size - current_size);
            if (preferred_size * multiple < min_size)
                return min_size;
            else
                return cast<sint04>(preferred_size * multiple);
        }
        /*void resizeEvent(QResizeEvent* event) override
        {
            refreshSizes();
            QSplitter::resizeEvent(event);
        }*/
        QSize minimumSizeHint() const override
        {
            return QSize(1, 1);
        }

        bool eventFilter(QObject* object, QEvent* event) override
        {
            switch (event->type())
            {
            case QEvent::LayoutRequest:
                refreshSizes();
                break;
            default:
                break;
            }
            return QSplitter::eventFilter(object, event);
        }

        void refreshSizes()
        {
            QList<int> current_sizes;
            int total_size = 0;
            for (int i = 0; i < count(); i++)
            {
                QWidget* w = widget(i);
                QSize size_hint = w->sizeHint();
                int local_size = getMax(1, orientation() == Qt::Orientation::Horizontal ? size_hint.width() : size_hint.height());
                total_size += local_size;
                current_sizes.append(local_size);
            }
            int our_size = (orientation() == Qt::Orientation::Horizontal) ? width() : height();
            if (total_size < our_size)
            {
                fltp08 size_multiple = cast<fltp08>(our_size) / cast<fltp08>(total_size);
                //QSize our_size = size();
                for (int i = 0; i < count(); i++)
                {
                    current_sizes[i] = cast<int>(size_multiple * current_sizes[i]);
                    /*if (orientation() == Qt::Orientation::Horizontal)
                        our_size.setWidth(current_sizes[i]);
                    else
                        our_size.setHeight(current_sizes[i]);
                    widget(i)->resize(our_size);*/
                }
            }
            setSizes(current_sizes);
            //repaint();
            //if(m_is_animating)
                //update();
        }

        void refreshSizes(int offset)
        {
            QList<int> current_sizes;
            int total_size = 0;
            for (int i = 0; i < count(); i++)
            {
                QWidget* w = widget(i);
                QSize size_hint = w->sizeHint();
                size_hint = size_hint.expandedTo(w->minimumSize());
                int local_size = getMax(1, orientation() == Qt::Orientation::Horizontal ? size_hint.width() : size_hint.height());
                total_size += local_size;
                current_sizes.append(local_size + offset);
            }
            int our_size = availableSize();
            if (total_size < our_size)
            {
                fltp08 size_multiple = cast<fltp08>(our_size) / cast<fltp08>(total_size);
                for (int i = 0; i < count(); i++)
                {
                    current_sizes[i] = cast<int>(size_multiple * current_sizes[i]);
                }
            }
            setSizes(current_sizes);
            //repaint();
            //if(m_is_animating)
                //update();
        }

        bool event(QEvent* e) override
        {
            if (m_block_events)
                return QWidget::event(e);
            else
                return QSplitter::event(e);
        }

        void childEvent(QChildEvent* c) override
        {
            if (c->removed()) 
            {
                bool visible = isVisible();
                if (visible)
                    setVisible(false);
                QSplitter::childEvent(c);
                if (visible)
                {
                    m_block_events = true;
                    setVisible(true);
                    m_block_events = false;
                }
                return;
            }
            else
            {
                return QSplitter::childEvent(c);
            }
        }
        bool m_block_events = false; 
        bool m_is_animating = false; 
    };
}