qTier/tierrow.cpp

#include "tierrow.hpp"
// #include "fullsizelayout.hpp"
#include "qmimedata.h"
#include "utils.hpp"
#include "settings.hpp"
#include "invalididexception.hpp"

#include <QHBoxLayout>

TierRow::TierRow(IdType id, QWidget *parent)
    : QWidget{parent}, _id(id)
{
    auto settings = Settings::get();
    setAcceptDrops(true);
    auto splitLayout = new QHBoxLayout();
    splitLayout->setSizeConstraint(QLayout::SetMinimumSize);
    splitLayout->setContentsMargins(0, 0, 0, 0);
    splitLayout->setSpacing(0);
    this->setLayout(splitLayout);
    titleCard = new TierRowTitleCard(id);
    cardContainer = new QWidget();
    cardContainer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    splitLayout->addWidget(titleCard, 0, Qt::AlignLeft | Qt::AlignTop);
    splitLayout->addWidget(cardContainer, 1, Qt::AlignTop);

    // cardContainer->setStyleSheet(makeBgColorString(QColor(60,60,60,100)));
    cardLayout = new FlowLayout(nullptr, 0, 0, 0);
    cardLayout->setSizeConstraint(QLayout::SetMinimumSize);
    cardLayout->setContentsMargins(0, 0, 0, 0);
    cardLayout->setSpacing(0);
    cardContainer->setLayout(cardLayout);
    connect(settings, SIGNAL(cardSizeChange(QSize)),
            this, SLOT(cardResize(QSize)));
    connect(settings, SIGNAL(rowFadeChange(float)),
            this, SLOT(fadeChange(float)));
    cardResize(settings->cardSize());
}

TierRow::~TierRow()
{
    // qDebug() << "Row destructor called " << id();
    if (idMap.erase(id()) == 0)
    {
        qDebug() << "Row id not found during destructor";
    }
}

void TierRow::addCard(TierCard* card)
{
    cardContainer->layout()->addWidget(card);
}
// TierCard* TierRow::takeCard(uint32_t id)
// {
//     for (auto i : cardContainer->children())
// }
void TierRow::setColor(QColor color)
{
    auto settings = Settings::get();
    auto fade = settings->rowFade();
    if (fade < 0)
        fade = 0;
    if (fade > 1)
        fade = 1;
    _color = color;
    const QColor wh(255,255,255);
    titleCard->setColor(color);
    auto fadedColor = blend(wh, color, fade);
    auto str = makeBgColorString(fadedColor);
    setStyleSheet(str);
}
QColor TierRow::color() const
{
    return _color;
}
void TierRow::setText(QString text)
{
    titleCard->setText(text);
}
QString TierRow::text() const
{
    return titleCard->text();
}
uint32_t TierRow::id() const
{
    return _id;
}

void TierRow::resizeEvent(QResizeEvent* event)
{
    this->QWidget::resizeEvent(event);
    recalcMaxHeight();
}

void TierRow::recalcMaxHeight()
{
    setMaximumHeight(cardLayout->totalMinimumHeightForWidth(
        cardContainer->width()));
}

TierRow* TierRow::create(QWidget* parent)
{
    TierRow* row;
    for (IdType id = 1;; id++)
    {
        if (idMap.find(id) == idMap.end())
        {
            row = new TierRow(id, parent);
            idMap[id] = row;
            return row;
        }
    }
}

TierRow* TierRow::getFromId(IdType id)
{
    auto iter = idMap.find(id);
    if (iter == idMap.end())
    {
        return nullptr;
    }
    return iter->second;
}

void TierRow::dropEvent(QDropEvent* event)
{
    qDebug() << "drop event";
    // auto source = event->source();
    //card dragged to this row
    if (event->mimeData()->hasFormat(TierCard::MimeType))
    {
        if (event->proposedAction() == Qt::MoveAction)
        {
            clearPlaceholder();
            auto data = event->mimeData()->data(TierCard::MimeType);
            QDataStream stream(&data, QIODevice::ReadOnly);
            TierCard::IdType cardId;
            stream.readRawData(reinterpret_cast<char*>(&cardId), sizeof(cardId));
            auto card = TierCard::getFromId(cardId);
            if (!card)
                throw InvalidCardIdException(cardId);
            // addCard(card);
            cardLayout->setIndex(card, calculateIndex(event->position()));
            event->acceptProposedAction();
        }
        else
        {
            event->ignore();
        }
    }
    //image(s) dragged to make new card(s)
    else if (event->mimeData()->hasImage())
    {

    }
}

void TierRow::dragEnterEvent(QDragEnterEvent* event)
{
    qDebug() << "drag enter event";
    if (cardCount() == 0)
    {
        qDebug() << "enter empty";
    }
    if (event->mimeData()->hasFormat(TierCard::MimeType))
    {
        if (event->proposedAction() == Qt::MoveAction)
        {
            if (placeholder != nullptr)
            {
                qDebug() << "placeholder not previously cleared";
                clearPlaceholder();
            }
            placeholder = new TierPlaceholder();
            cardLayout->setIndex(placeholder, calculateIndex(event->position()));
            event->setDropAction(Qt::MoveAction);
            event->accept(cardContainer->rect());
        }
        else
        {
            event->setDropAction(Qt::MoveAction);
            event->accept(cardContainer->geometry());
        }
    }
    else if (event->mimeData()->hasImage())
    {
        event->setDropAction(Qt::CopyAction);
        event->accept();
    }
    else {
        event->ignore();
    }
}

void TierRow::dragMoveEvent(QDragMoveEvent* event)
{
    if (event->mimeData()->hasFormat(TierCard::MimeType))
    {
        if (event->proposedAction() == Qt::MoveAction)
        {
            if (cardCount() == 1)
            {
                qDebug() << "moving in empty";
            }
            if (placeholder)
                cardLayout->setIndex(placeholder, calculateIndex(event->position()));
            event->acceptProposedAction();
        }
        else
        {
            event->setDropAction(Qt::MoveAction);
            event->accept(cardContainer->geometry());
        }
    }
    else if (event->mimeData()->hasImage())
    {
        event->setDropAction(Qt::CopyAction);
        //TODO event->accept();
        event->ignore();
    }
    else
    {
        event->ignore();
    }
}

void TierRow::dragLeaveEvent(QDragLeaveEvent* event)
{
    clearPlaceholder();
}

void TierRow::clearPlaceholder()
{
    placeholder->setParent(nullptr);
    placeholder->deleteLater();
    placeholder = nullptr;
}

int TierRow::calculateIndex(QPointF loc)
{
    auto settings = Settings::get();
    auto cardSize = settings->cardSize();
    auto cardCenter = loc + QPointF(cardSize.width() / 2,
                                    cardSize.height() / 2);
    auto lastBefore = 0;
    for (int i = 0; i < cardLayout->count(); i++)
    {
        auto refCard = cardLayout->itemAt(i);
        auto refPos = refCard->widget()->pos();
        if (cardCenter.y() > refPos.y()
            && cardCenter.x() > refPos.x())
            lastBefore = i;
        else
            break;
    }
    return lastBefore;
}

void TierRow::cardResize(QSize newSize)
{
    titleCard->setFixedSize(newSize);
    cardContainer->setMinimumHeight(newSize.height());
    cardContainer->updateGeometry();
    updateGeometry();
    Settings::get()->mainWindow()->updateGeometry();
}

void TierRow::fadeChange(float newFade)
{
    setColor(_color);
}

int TierRow::cardCount() const
{
    return cardLayout->count();
}