QtNovelUI/libSplitView/splitpanel.cpp

#include "splitpanel.h"
#include "baseview.h"
#include <QPainter>
#include <libConfig.h>

using namespace split_frame;
using namespace split_panel;
using namespace Config;

SplitPanel::SplitPanel(ViewBase *first, ViewBase *next, ViewRes *parent)
    : QWidget(parent->widget()), parent_inst(parent)
{
    this->split_member = std::make_tuple(first, next, SplitType::SPLIT_H);
}

SplitPanel::~SplitPanel()
{

}

ResManager *SplitPanel::splitManager() const { return this->parent_inst->splitManager(); }

ViewRes *SplitPanel::parentRes() const
{
    return parent_inst;
}

bool SplitPanel::canRetrieve() const
{
    return true;
}

bool SplitPanel::canClose() const
{
    return true;
}

bool SplitPanel::canReplace() const
{
    return true;
}

QIcon SplitPanel::icon() const
{
    return QIcon();
}

QString SplitPanel::title() const
{
    return QString("split-view：%1").arg((int64_t)this);
}

QWidget *SplitPanel::widget() const
{
    return const_cast<SplitPanel*>(this);
}

QSizeF SplitPanel::viewSize() const
{
    return this->size();
}

void SplitPanel::resizeView(const QSizeF &outline)
{
    if(outline != this->size()){
        this->resize(outline.toSize());
    }


    auto tuple_values = this->child();

    if(view_list().size() == 1){
        view_list().first()->resizeView(this->viewSize());
    }
    else{
        switch (std::get<2>(tuple_values)) {
        case SplitType::SPLIT_H: {
            auto width_value = QWidget::width() * this->splitterPos();
            std::get<0>(tuple_values)->widget()->setGeometry(0, 0, width_value, QWidget::height());

            auto second_pos = width_value + splitterWidth();
            auto second_width = QWidget::width() - second_pos;
            std::get<1>(tuple_values)->widget()->setGeometry(second_pos, 0, second_width, QWidget::height());
        } break;
        case SplitType::SPLIT_V: {
            auto height_value = QWidget::height() * this->splitterPos();
            std::get<0>(tuple_values)->widget()->setGeometry(0, 0, QWidget::width(), height_value);

            auto second_pos = height_value + splitterWidth();
            auto second_height = QWidget::height() - second_pos;
            std::get<1>(tuple_values)->widget()->setGeometry(0, second_pos, QWidget::width(), second_height);
        } break;
        }
    }
}

std::tuple<ViewBase *, ViewBase *, SplitType> SplitPanel::child() const
{
    return this->split_member;
}

void SplitPanel::replaceComp(ViewBase *view, ViewBase *old)
{
    QList<ViewBase*> mbrs = view_list();

    if(!mbrs.contains(view) && mbrs.contains(old)){
        if(std::get<1>(split_member) == old){
            this->split_member = std::make_tuple(std::get<0>(split_member), view, std::get<2>(split_member));
        }
        else if(std::get<0>(split_member) == old){
            this->split_member = std::make_tuple(view, std::get<1>(split_member), std::get<2>(split_member));
        }

        old->widget()->setParent(nullptr);
        view->widget()->setParent(this);
        this->resizeView(this->viewSize());
    }
}

float SplitPanel::splitterWidth() const
{
    return std::get<1>(split_info_value);
}

float SplitPanel::splitterPos() const
{
    return std::get<0>(split_info_value);
}

void SplitPanel::setSplitInfo(split_frame::SplitType type, float pos, float width)
{
    this->split_member = std::make_tuple(std::get<0>(split_member), std::get<1>(split_member), type);
    this->split_info_value = std::make_tuple(pos, width);
}


QList<ViewBase *> SplitPanel::view_list() const
{
    QList<ViewBase*> items;

    if(std::get<0>(split_member))
        items << std::get<0>(split_member);
    if(std::get<1>(split_member))
        items << std::get<1>(split_member);

    return items;
}