textautogeneratelistviewdelegate.cpp

/*
  SPDX-FileCopyrightText: 2025 Laurent Montel <montel@kde.org>
 
  SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "textautogeneratelistviewdelegate.h"
#include "core/textautogeneratechatmodel.h"
#include "textautogeneratecolorsandmessageviewstyle.h"
#include "textautogeneratedelegateutils.h"
#include "textautogeneratelistviewtextselection.h"
#include "textautogeneratetextwidget_debug.h"
#include <KLocalizedString>
#include <QAbstractTextDocumentLayout>
#include <QDesktopServices>
#include <QDrag>
#include <QListView>
#include <QMimeData>
#include <QPainter>
#include <QTextFrame>
#include <QTextFrameFormat>
#include <QToolTip>
 
using namespace TextAutogenerateText;
TextAutogenerateListViewDelegate::TextAutogenerateListViewDelegate(QListView *view)
    : QItemDelegate{view}
    , mEditedIcon(QIcon::fromTheme(QStringLiteral("document-edit")))
    , mRemoveIcon(QIcon::fromTheme(QStringLiteral("edit-delete")))
    , mCopyIcon(QIcon::fromTheme(QStringLiteral("edit-copy")))
    , mCancelIcon(QIcon::fromTheme(QStringLiteral("dialog-cancel")))
    , mListView(view)
    , mTextSelection(new TextAutogenerateListViewTextSelection(this, this))
{
    mSizeHintCache.setMaxEntries(32);
    connect(mTextSelection, &TextAutogenerateListViewTextSelection::repaintNeeded, this, &TextAutogenerateListViewDelegate::updateView);
    connect(&TextAutogenerateColorsAndMessageViewStyle::self(),
            &TextAutogenerateColorsAndMessageViewStyle::needToUpdateColors,
            this,
            &TextAutogenerateListViewDelegate::slotUpdateColors);
    slotUpdateColors();
}
 
TextAutogenerateListViewDelegate::~TextAutogenerateListViewDelegate() = default;
 
void TextAutogenerateListViewDelegate::slotUpdateColors()
{
    const KColorScheme scheme = TextAutogenerateColorsAndMessageViewStyle::self().schemeView();
    mEditingColorMode = scheme.foreground(KColorScheme::NegativeText).color();
    // Q_EMIT updateView();
}
 
void TextAutogenerateListViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    painter->save();
    drawBackground(painter, option, index);
    painter->restore();
 
    const MessageLayout layout = doLayout(option, index);
    if (layout.textRect.isValid()) {
        painter->save();
        const TextAutoGenerateMessage::Sender sender = index.data(TextAutoGenerateChatModel::SenderRole).value<TextAutoGenerateMessage::Sender>();
        const bool isUser = (sender == TextAutoGenerateMessage::Sender::User);
        painter->setPen(QPen(Qt::NoPen));
 
        auto it = std::find_if(mIndexBackgroundColorList.cbegin(), mIndexBackgroundColorList.cend(), [index](const IndexBackgroundColor &key) {
            return key.index == index;
        });
        QColor messageBackgroundColor;
        if (it != mIndexBackgroundColorList.cend()) {
            messageBackgroundColor = it->color;
        }
        if (index.data(TextAutoGenerateChatModel::EditingRole).toBool()) {
            messageBackgroundColor = mEditingColorMode;
        }
 
        if (isUser) {
            if (messageBackgroundColor.isValid() && messageBackgroundColor != QColor(Qt::transparent)) {
                painter->setBrush(QBrush(messageBackgroundColor));
            } else {
                painter->setBrush(QBrush(option.palette.color(QPalette::Inactive, QPalette::Midlight)));
            }
        } else {
            painter->setBrush(QBrush(option.palette.color(QPalette::Active, QPalette::Mid)));
        }
        painter->setRenderHint(QPainter::Antialiasing);
        painter->drawRoundedRect(
            QRect(layout.decoRect.topLeft(), QSize(layout.decoRect.width(), layout.decoRect.height() - TextAutogenerateDelegateUtils::spacingText() - 5)),
            TextAutogenerateDelegateUtils::roundRectValue(),
            TextAutogenerateDelegateUtils::roundRectValue());
        painter->restore();
        draw(painter, layout, index, option);
    }
    /*
    painter->save();
    painter->setPen(QPen(Qt::green));
    painter->drawRect(layout.decoRect);
    painter->restore();
    */
}
 
void TextAutogenerateListViewDelegate::draw(QPainter *painter, const MessageLayout &layout, const QModelIndex &index, const QStyleOptionViewItem &option) const
{
    QRect rect = layout.textRect;
    auto *doc = documentForIndex(index, rect.width());
    if (!doc) {
        return;
    }
    painter->save();
    painter->translate(rect.left(), rect.top());
    const QRect clip(0, 0, rect.width(), rect.height());
 
    QAbstractTextDocumentLayout::PaintContext ctx;
    if (mTextSelection) {
        const QList<QAbstractTextDocumentLayout::Selection> selections = TextAutogenerateDelegateUtils::selection(mTextSelection, doc, index, option);
        // Same as pDoc->drawContents(painter, clip) but we also set selections
        ctx.selections = selections;
        if (clip.isValid()) {
            painter->setClipRect(clip);
            ctx.clip = clip;
        }
    }
    doc->documentLayout()->draw(painter, ctx);
    painter->restore();
    drawDateAndIcons(painter, index, option, layout);
    drawInProgressIndicator(painter, index, option, layout);
}
 
void TextAutogenerateListViewDelegate::drawInProgressIndicator(QPainter *painter,
                                                               const QModelIndex &index,
                                                               const QStyleOptionViewItem &option,
                                                               const MessageLayout &layout) const
{
    Q_UNUSED(option);
    auto it = std::find_if(mIndexScaleAndOpacitiesList.cbegin(), mIndexScaleAndOpacitiesList.cend(), [index](const IndexScaleAndOpacities &key) {
        return key.index == index;
    });
    if (it == mIndexScaleAndOpacitiesList.cend()) {
        return;
    }
    const auto scaleAndOpacities = (*it).scaleAndOpacities;
    painter->save();
    painter->setRenderHint(QPainter::Antialiasing);
 
    const int dotSize = 5;
    const int spacing = TextAutogenerateDelegateUtils::iconSpacing();
 
    for (int i = 0; i < scaleAndOpacities.count(); ++i) {
        const TextAutogenerateText::TextAutogenerateMessageWaitingAnswerAnimation::ScaleAndOpacity value = scaleAndOpacities.value(i);
        painter->setOpacity(value.opacity);
        // qDebug() << " value " << value;
        painter->save();
        painter->translate(layout.inProgressRect.x() + spacing + i * (dotSize + spacing), layout.inProgressRect.top() + layout.inProgressRect.height() / 2);
        painter->rotate(45);
        painter->scale(value.scale, value.scale);
        painter->setBrush(Qt::black);
        painter->drawEllipse(-dotSize / 2, -dotSize / 2, dotSize, dotSize);
        painter->restore();
    }
    painter->restore();
}
 
void TextAutogenerateListViewDelegate::drawDateAndIcons(QPainter *painter,
                                                        const QModelIndex &index,
                                                        const QStyleOptionViewItem &option,
                                                        const MessageLayout &layout) const
{
    const bool isMouseOver = index.data(TextAutoGenerateChatModel::MouseHoverRole).toBool();
    if (layout.dateSize.isValid()) {
        const QPen origPen = painter->pen();
        const qreal margin = TextAutogenerateDelegateUtils::leftLLMIndent();
        const QString dateStr = index.data(TextAutoGenerateChatModel::DateTimeStrRole).toString();
 
        /*
        // qDebug() << " draw date" << dateAreaRect << layout.decoRect;
        painter->save();
        painter->setPen(QPen(Qt::yellow));
        painter->drawRect(dateAreaRect);
        painter->restore();
        */
 
        const QRect dateTextRect = QStyle::alignedRect(Qt::LayoutDirectionAuto, Qt::AlignCenter, layout.dateSize, layout.dateAreaRect);
        QColor lightColor(painter->pen().color());
        lightColor.setAlpha(60);
        painter->setPen(lightColor);
        painter->drawText(dateTextRect, dateStr);
        // qDebug() << " dateTextRect" << dateTextRect;
        const int lineY = (layout.dateAreaRect.top() + layout.dateAreaRect.bottom()) / 2;
        painter->drawLine(layout.dateAreaRect.left(), lineY, dateTextRect.left() - margin, lineY);
        int iconSize = isMouseOver ? buttonIconSize(option) : 0;
        const bool inProgress = index.data(TextAutoGenerateChatModel::FinishedRole).toBool();
        if (!inProgress) {
            iconSize = 2 * iconSize + TextAutogenerateDelegateUtils::iconSpacing();
        }
        painter->drawLine(dateTextRect.right() + margin, lineY, layout.dateAreaRect.right() - iconSize, lineY);
        painter->setPen(origPen);
    }
 
    if (isMouseOver) {
        // Draw the edited icon
        if (layout.editedIconRect.isValid()) {
            mEditedIcon.paint(painter, layout.editedIconRect);
        }
        if (layout.removeIconRect.isValid()) {
            mRemoveIcon.paint(painter, layout.removeIconRect);
        }
        if (layout.copyIconRect.isValid()) {
            mCopyIcon.paint(painter, layout.copyIconRect);
        }
        if (layout.cancelIconRect.isValid()) {
            mCancelIcon.paint(painter, layout.cancelIconRect);
        }
    }
}
 
QSize TextAutogenerateListViewDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    const QByteArray uuid = index.data(TextAutoGenerateChatModel::UuidRole).toByteArray();
    auto it = mSizeHintCache.find(uuid);
    if (it != mSizeHintCache.end()) {
        const QSize result = it->value;
        qCDebug(TEXTAUTOGENERATETEXT_WIDGET_LOG) << "TextAutogenerateListViewDelegate: SizeHint found in cache: " << result;
        return result;
    }
 
    const TextAutogenerateListViewDelegate::MessageLayout layout = doLayout(option, index);
 
    int additionalHeight = 0;
    // A little bit of margin below the very last item, it just looks better
    if (index.row() == index.model()->rowCount() - 1) {
        additionalHeight += 4;
    }
 
    const QSize size = {layout.decoRect.width(), layout.decoRect.height() + additionalHeight + (layout.dateSize.isValid() ? layout.dateSize.height() : 16)};
    if (!size.isEmpty()) {
        mSizeHintCache.insert(uuid, size);
    }
    return size;
}
 
void TextAutogenerateListViewDelegate::clearCache()
{
    clearSizeHintCache();
    mDocumentCache.clear();
}
 
void TextAutogenerateListViewDelegate::clearSizeHintCache()
{
    mSizeHintCache.clear();
}
 
void TextAutogenerateListViewDelegate::removeMessageCache(const QByteArray &uuid)
{
    mDocumentCache.remove(uuid);
    mSizeHintCache.remove(uuid);
}
 
int TextAutogenerateListViewDelegate::buttonIconSize(const QStyleOptionViewItem &option) const
{
    return option.widget->style()->pixelMetric(QStyle::PM_ButtonIconSize);
}
 
TextAutogenerateListViewDelegate::MessageLayout TextAutogenerateListViewDelegate::doLayout(const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    const int iconSize = buttonIconSize(option);
    TextAutogenerateListViewDelegate::MessageLayout layout;
    QRect usableRect = option.rect;
    const TextAutoGenerateMessage::Sender sender = index.data(TextAutoGenerateChatModel::SenderRole).value<TextAutoGenerateMessage::Sender>();
    const bool isUser = (sender == TextAutoGenerateMessage::Sender::User);
    const int indent = isUser ? TextAutogenerateDelegateUtils::leftUserIndent() : TextAutogenerateDelegateUtils::leftLLMIndent();
    if (!isUser) {
        const QString dateStr = index.data(TextAutoGenerateChatModel::DateTimeStrRole).toString();
        layout.dateSize = option.fontMetrics.size(Qt::TextSingleLine, dateStr);
        usableRect.setBottom(usableRect.bottom() + layout.dateSize.height());
    } else {
        usableRect.setBottom(usableRect.bottom() + iconSize);
    }
 
    int maxWidth = qMax(30, option.rect.width() - indent - TextAutogenerateDelegateUtils::rightIndent());
    const QSize textSize = sizeHint(index, maxWidth, option, &layout.baseLine);
    if (isUser) {
        maxWidth = qMax(30, textSize.width() + TextAutogenerateDelegateUtils::rightIndent() + TextAutogenerateDelegateUtils::marginText());
    }
 
    if (isUser) {
        layout.textRect = QRect(option.rect.width() - maxWidth,
                                usableRect.top() + TextAutogenerateDelegateUtils::spacingText() * 2,
                                maxWidth - TextAutogenerateDelegateUtils::marginText() * 2,
                                textSize.height() + TextAutogenerateDelegateUtils::spacingText() * 2);
 
        layout.decoRect = QRect(layout.textRect.x() - TextAutogenerateDelegateUtils::rightIndent(),
                                usableRect.top() + TextAutogenerateDelegateUtils::spacingText(),
                                maxWidth,
                                layout.textRect.height() + TextAutogenerateDelegateUtils::spacingText() * 3);
 
    } else {
        layout.textRect = QRect(indent + TextAutogenerateDelegateUtils::marginText(),
                                usableRect.top() + TextAutogenerateDelegateUtils::spacingText() * 2,
                                maxWidth - TextAutogenerateDelegateUtils::marginText() * 2,
                                textSize.height() + TextAutogenerateDelegateUtils::spacingText() * 2);
 
        layout.decoRect = QRect(indent,
                                usableRect.top() + TextAutogenerateDelegateUtils::spacingText(),
                                maxWidth,
                                layout.textRect.height() + TextAutogenerateDelegateUtils::spacingText() * 3);
    }
    layout.dateAreaRect = QRect(layout.decoRect.x(),
                                layout.textRect.y() + layout.textRect.height() + TextAutogenerateDelegateUtils::spacingText(),
                                layout.decoRect.width(),
                                qMax(layout.dateSize.height(), iconSize)); // the whole row
 
    int positionIcon = layout.decoRect.right() - iconSize;
    const int lineY = (layout.dateAreaRect.top() + layout.dateAreaRect.bottom() - iconSize) / 2;
    if (isUser) {
        layout.removeIconRect = QRect(positionIcon, lineY, iconSize, iconSize);
        positionIcon -= iconSize + TextAutogenerateDelegateUtils::iconSpacing();
        layout.editedIconRect = QRect(positionIcon, lineY, iconSize, iconSize);
        positionIcon -= iconSize + TextAutogenerateDelegateUtils::iconSpacing();
    } else {
        const bool inProgress = index.data(TextAutoGenerateChatModel::FinishedRole).toBool();
        if (!inProgress) {
            layout.cancelIconRect = QRect(positionIcon, lineY, iconSize, iconSize);
            positionIcon -= iconSize + TextAutogenerateDelegateUtils::iconSpacing();
        }
    }
    layout.copyIconRect = QRect(positionIcon, lineY, iconSize, iconSize);
 
    // TODO fix it
    layout.inProgressRect = QRect(layout.textRect.x(), layout.textRect.y() + layout.textRect.height() - 20, 60, 20);
 
    return layout;
}
 
QSize TextAutogenerateListViewDelegate::sizeHint(const QModelIndex &index, int maxWidth, const QStyleOptionViewItem &option, qreal *pBaseLine) const
{
    Q_UNUSED(option)
    auto *doc = documentForIndex(index, maxWidth);
    return textSizeHint(doc, pBaseLine);
}
 
QSize TextAutogenerateListViewDelegate::textSizeHint(QTextDocument *doc, qreal *pBaseLine) const
{
    if (!doc) {
        return {};
    }
    const QSize size(doc->idealWidth(), doc->size().height()); // do the layouting, required by lineAt(0) below
 
    const QTextLine &line = doc->firstBlock().layout()->lineAt(0);
    *pBaseLine = line.y() + line.ascent(); // relative
    // qDebug() << " doc->" << doc->toPlainText() << " size " << size;
    return size;
}
 
void TextAutogenerateListViewDelegate::selectAll(const QStyleOptionViewItem &option, const QModelIndex &index)
{
    Q_UNUSED(option);
    mTextSelection->selectMessage(index);
    mListView->update(index);
    TextAutogenerateDelegateUtils::setClipboardSelection(mTextSelection);
}
 
bool TextAutogenerateListViewDelegate::mouseEvent(QEvent *event, const QStyleOptionViewItem &option, const QModelIndex &index)
{
    const QEvent::Type eventType = event->type();
    if (eventType == QEvent::MouseButtonRelease) {
        auto mev = static_cast<QMouseEvent *>(event);
        const TextAutogenerateListViewDelegate::MessageLayout layout = doLayout(option, index);
        if (handleMouseEvent(mev, layout.decoRect, option, index)) {
            return true;
        }
    } else if (eventType == QEvent::MouseButtonPress || eventType == QEvent::MouseMove || eventType == QEvent::MouseButtonDblClick) {
        auto mev = static_cast<QMouseEvent *>(event);
        if (mev->buttons() & Qt::LeftButton) {
            const TextAutogenerateListViewDelegate::MessageLayout layout = doLayout(option, index);
            if (handleMouseEvent(mev, layout.decoRect, option, index)) {
                return true;
            }
        }
    }
    return false;
}
 
bool TextAutogenerateListViewDelegate::helpEvent(QHelpEvent *helpEvent, QAbstractItemView *view, const QStyleOptionViewItem &option, const QModelIndex &index)
{
    if (!index.isValid()) {
        return false;
    }
    if (helpEvent->type() == QEvent::ToolTip) {
        const TextAutogenerateListViewDelegate::MessageLayout layout = doLayout(option, index);
        const QPoint helpEventPos{helpEvent->pos()};
        if (layout.textRect.contains(helpEventPos)) {
            const auto *doc = documentForIndex(index, layout.textRect.width());
            if (!doc) {
                return false;
            }
 
            const QPoint pos = helpEvent->pos() - layout.textRect.topLeft();
            QString formattedTooltip;
            if (TextAutogenerateDelegateUtils::generateToolTip(doc, pos, formattedTooltip)) {
                QToolTip::showText(helpEvent->globalPos(), formattedTooltip, view);
                return true;
            }
            return true;
        }
        if (layout.removeIconRect.contains(helpEventPos)) {
            QToolTip::showText(helpEvent->globalPos(), i18nc("@info:tooltip", "Remove"), view);
            return true;
        }
        if (layout.editedIconRect.contains(helpEventPos)) {
            QToolTip::showText(helpEvent->globalPos(), i18nc("@info:tooltip", "Edit..."), view);
            return true;
        }
        if (layout.copyIconRect.contains(helpEventPos)) {
            QToolTip::showText(helpEvent->globalPos(), i18nc("@info:tooltip", "Copy"), view);
            return true;
        }
        if (layout.cancelIconRect.contains(helpEventPos)) {
            QToolTip::showText(helpEvent->globalPos(), i18nc("@info:tooltip", "Cancel"), view);
            return true;
        }
    }
    return false;
}
 
QTextDocument *TextAutogenerateListViewDelegate::documentForIndex(const QModelIndex &index, int width) const
{
    Q_ASSERT(index.isValid());
    const QByteArray uuid = index.data(TextAutoGenerateChatModel::UuidRole).toByteArray();
    Q_ASSERT(!uuid.isEmpty());
    auto it = mDocumentCache.find(uuid);
    if (it != mDocumentCache.end()) {
        auto ret = it->value.get();
        if (width != -1 && !qFuzzyCompare(ret->textWidth(), width)) {
            ret->setTextWidth(width);
        }
        return ret;
    }
 
    const QString text = index.data(TextAutoGenerateChatModel::MessageRole).toString();
    if (text.isEmpty()) {
        return nullptr;
    }
    auto doc = createTextDocument(text, width);
    auto ret = doc.get();
    mDocumentCache.insert(uuid, std::move(doc));
    return ret;
}
 
std::unique_ptr<QTextDocument> TextAutogenerateListViewDelegate::createTextDocument(const QString &text, int width) const
{
    std::unique_ptr<QTextDocument> doc(new QTextDocument);
    // doc->setMarkdown(text);
    doc->setHtml(text);
    doc->setTextWidth(width);
    QTextFrame *frame = doc->frameAt(0);
    QTextFrameFormat frameFormat = frame->frameFormat();
    frameFormat.setMargin(0);
    frame->setFrameFormat(frameFormat);
    return doc;
}
QString TextAutogenerateListViewDelegate::selectedText() const
{
    return mTextSelection->selectedText(TextAutogenerateListViewTextSelection::Format::Text);
}
 
bool TextAutogenerateListViewDelegate::hasSelection() const
{
    return mTextSelection->hasSelection();
}
 
bool TextAutogenerateListViewDelegate::maybeStartDrag(QMouseEvent *event, const QStyleOptionViewItem &option, const QModelIndex &index)
{
    const TextAutogenerateListViewDelegate::MessageLayout layout = doLayout(option, index);
    if (maybeStartDrag(event, layout.textRect, option, index)) {
        return true;
    }
    return false;
}
 
bool TextAutogenerateListViewDelegate::maybeStartDrag(QMouseEvent *mouseEvent, QRect messageRect, const QStyleOptionViewItem &option, const QModelIndex &index)
{
    if (!mTextSelection->mightStartDrag()) {
        return false;
    }
    if (mTextSelection->hasSelection()) {
        const QPoint pos = mouseEvent->pos() - messageRect.topLeft();
        const auto *doc = documentForIndex(index, messageRect.width());
        const int charPos = doc->documentLayout()->hitTest(pos, Qt::FuzzyHit);
        if (charPos != -1 && mTextSelection->contains(index, charPos)) {
            auto mimeData = new QMimeData;
            mimeData->setHtml(mTextSelection->selectedText(TextAutogenerateListViewTextSelection::Format::Html));
            mimeData->setText(mTextSelection->selectedText(TextAutogenerateListViewTextSelection::Format::Text));
            auto drag = new QDrag(const_cast<QWidget *>(option.widget));
            drag->setMimeData(mimeData);
            drag->exec(Qt::CopyAction);
            mTextSelection->setMightStartDrag(false); // don't clear selection on release
            return true;
        }
    }
    return false;
}
bool TextAutogenerateListViewDelegate::handleMouseEvent(QMouseEvent *mouseEvent,
                                                        QRect messageRect,
                                                        const QStyleOptionViewItem &option,
                                                        const QModelIndex &index)
{
    Q_UNUSED(option)
    if (!messageRect.contains(mouseEvent->pos())) {
        return false;
    }
 
    const QPoint pos = mouseEvent->pos() - messageRect.topLeft();
    const QEvent::Type eventType = mouseEvent->type();
 
    // Text selection
    switch (eventType) {
    case QEvent::MouseButtonPress:
        mTextSelection->setMightStartDrag(false);
        if (const auto *doc = documentForIndex(index, messageRect.width())) {
            const int charPos = doc->documentLayout()->hitTest(pos, Qt::FuzzyHit);
            qCDebug(TEXTAUTOGENERATETEXT_WIDGET_LOG) << "pressed at pos" << charPos;
            if (charPos == -1) {
                return false;
            }
            if (mTextSelection->contains(index, charPos) && doc->documentLayout()->hitTest(pos, Qt::ExactHit) != -1) {
                mTextSelection->setMightStartDrag(true);
                return true;
            }
 
            // QWidgetTextControl also has code to support selectBlockOnTripleClick, shift to extend selection
            // (look there if you want to add these things)
 
            mTextSelection->setTextSelectionStart(index, charPos);
            return true;
        } else {
            mTextSelection->clear();
        }
        break;
    case QEvent::MouseMove:
        if (!mTextSelection->mightStartDrag()) {
            if (const auto *doc = documentForIndex(index, messageRect.width())) {
                const int charPos = doc->documentLayout()->hitTest(pos, Qt::FuzzyHit);
                if (charPos != -1) {
                    // QWidgetTextControl also has code to support isPreediting()/commitPreedit(), selectBlockOnTripleClick
                    mTextSelection->setTextSelectionEnd(index, charPos);
                    return true;
                }
            }
        }
        break;
    case QEvent::MouseButtonRelease: {
        qCDebug(TEXTAUTOGENERATETEXT_WIDGET_LOG) << "released";
        const TextAutogenerateListViewDelegate::MessageLayout layout = doLayout(option, index);
        TextAutogenerateDelegateUtils::setClipboardSelection(mTextSelection);
        // Clicks on links
        if (!mTextSelection->hasSelection()) {
            if (const auto *doc = documentForIndex(index, messageRect.width())) {
                const QString link = doc->documentLayout()->anchorAt(pos);
                if (!link.isEmpty()) {
                    QDesktopServices::openUrl(QUrl(link));
                    return true;
                }
            }
        } else if (mTextSelection->mightStartDrag()) {
            // clicked into selection, didn't start drag, clear it (like kwrite and QTextEdit)
            mTextSelection->clear();
        }
        if (layout.editedIconRect.contains(mouseEvent->pos())) {
            Q_EMIT editMessage(index);
            return true;
        } else if (layout.copyIconRect.contains(mouseEvent->pos())) {
            Q_EMIT copyMessage(index);
            return true;
        } else if (layout.removeIconRect.contains(mouseEvent->pos())) {
            Q_EMIT removeMessage(index);
            return true;
        } else if (layout.cancelIconRect.contains(mouseEvent->pos())) {
            Q_EMIT cancelRequest(index);
            return true;
        }
        // don't return true here, we need to send mouse release events to other helpers (ex: click on image)
        break;
    }
    case QEvent::MouseButtonDblClick:
        if (!mTextSelection->hasSelection()) {
            if (const auto *doc = documentForIndex(index, messageRect.width())) {
                const int charPos = doc->documentLayout()->hitTest(pos, Qt::FuzzyHit);
                qCDebug(TEXTAUTOGENERATETEXT_WIDGET_LOG) << "double-clicked at pos" << charPos;
                if (charPos == -1) {
                    return false;
                }
                mTextSelection->selectWordUnderCursor(index, charPos);
                return true;
            }
        }
        break;
    default:
        break;
    }
 
    return false;
}
 
void TextAutogenerateListViewDelegate::needUpdateIndexBackground(const QPersistentModelIndex &index, const QColor &color)
{
    removeNeedUpdateIndexBackground(index);
    const IndexBackgroundColor back{.index = index, .color = color};
    mIndexBackgroundColorList.append(std::move(back));
}
 
void TextAutogenerateListViewDelegate::removeNeedUpdateIndexBackground(const QPersistentModelIndex &index)
{
    auto it = std::find_if(mIndexBackgroundColorList.cbegin(), mIndexBackgroundColorList.cend(), [index](const IndexBackgroundColor &key) {
        return key.index == index;
    });
    if (it != mIndexBackgroundColorList.cend()) {
        mIndexBackgroundColorList.erase(it);
    }
}
 
void TextAutogenerateListViewDelegate::needUpdateWaitingAnswerAnimation(
    const QPersistentModelIndex &index,
    const QList<TextAutogenerateMessageWaitingAnswerAnimation::ScaleAndOpacity> &scaleAndOpacities)
{
    removeNeedUpdateWaitingAnswerAnimation(index);
    const IndexScaleAndOpacities back{.index = index, .scaleAndOpacities = scaleAndOpacities};
    mIndexScaleAndOpacitiesList.append(std::move(back));
}
 
void TextAutogenerateListViewDelegate::removeNeedUpdateWaitingAnswerAnimation(const QPersistentModelIndex &index)
{
    auto it = std::find_if(mIndexScaleAndOpacitiesList.cbegin(), mIndexScaleAndOpacitiesList.cend(), [index](const IndexScaleAndOpacities &key) {
        return key.index == index;
    });
    if (it != mIndexScaleAndOpacitiesList.cend()) {
        mIndexScaleAndOpacitiesList.erase(it);
    }
}
 
#include "moc_textautogeneratelistviewdelegate.cpp"