qTier/tierrow.cpp

#include "tierrow.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)
        {
            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);
            // auto index = calculateIndex(event->position());
            // if (index > placeholderIndex)
            //     index--;
            const auto index = placeholderIndex;
            clearPlaceholder();
            cardLayout->setIndex(card, index);
            event->acceptProposedAction();
        }
        else
        {
            event->ignore();
        }
    }
    //image(s) dragged to make new card(s)
    else if (event->mimeData()->hasImage())
    {

    }
}

void TierRow::dragEnterEvent(QDragEnterEvent* event)
{
    qInfo() << "DRAG ENTER EVENT";
    if (event->mimeData()->hasFormat(TierCard::MimeType))
    {
        if (event->proposedAction() == Qt::MoveAction)
        {
            if (placeholder)
            {
                qWarning() << "placeholder not previously cleared";
            }
            else
            {
                placeholder = new TierPlaceholder();
            }
            placeholderIndex = calculateIndex(event->position());
            cardLayout->setIndex(placeholder, placeholderIndex);
            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);
        //TODO event->accept();
        event->ignore();
    }
    else
    {
        event->ignore();
    }
}

void TierRow::dragMoveEvent(QDragMoveEvent* event)
{
    qInfo() << "DRAG MOVE EVENT";
    if (event->mimeData()->hasFormat(TierCard::MimeType))
    {
        if (event->proposedAction() == Qt::MoveAction)
        {
            if (placeholder)
            {
                if (!placeholder->rect().contains(event->position().toPoint()))
                {
                    auto newPlaceholderIndex = calculateIndex(event->position());
                    if (newPlaceholderIndex >= placeholderIndex)
                        newPlaceholderIndex--;
                    placeholderIndex = newPlaceholderIndex;
                    cardLayout->setIndex(placeholder, placeholderIndex);
                }
            }
            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()
{
    placeholderIndex = 0;
    placeholder->setParent(nullptr);
    placeholder->deleteLater();
    placeholder = nullptr;
}

int TierRow::calculateIndex(QPointF loc)
{
    qInfo() << "Starting calculate index";
    qInfo() << "location" << loc;
    auto settings = Settings::get();
    auto cardSize = settings->cardSize();
    qInfo() << "card size" << cardSize;
    // auto cardCenter = loc + QPointF(cardSize.width() / 2,
    //                                 cardSize.height() / 2);
    auto cardCenter = loc;
    auto offset = QPoint(midpoint(cardSize).x(), 0);
    qInfo() << "card center" << cardCenter;
    auto lastBefore = -1;
    qInfo() << "card layout ptr" << cardLayout;
    const auto size = cardLayout->count();
    const auto useLoc = loc + QPoint(cardSize.width() / 2,
                                     cardSize.height() / 2);
    qInfo() << "size" << size;
    for (int i = 0; i < size; i++)
    {
        qInfo() << "getting item at index" << i;
        auto refCard = cardLayout->itemAt(i);
        qInfo() << "index" << i << "geometry" << refCard->geometry();
        // auto refPos = refCard->widget()->pos() + offset;
        if (isAfter(refCard->widget(), useLoc, ComparePoint::TopCenter))
            lastBefore = i;
        else
            break;
    }
    // qInfo() << "last before" << cardLayout->itemAt(lastBefore)->widget()->pos()
    //         << "index" << lastBefore;
    const auto retVal = lastBefore+1;
    qInfo() << "calculated index" << retVal;
    return retVal;
}

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();
}