raven-rhel8/extras/KF6/gear/gwenview/gwenview-24.05.1/lib/zoomcombobox/zoomcombobox.cpp

// SPDX-FileCopyrightText: 2021 Noah Davis <noahadvs@gmail.com>
// SPDX-License-Identifier: LGPL-2.1-or-later

#include "zoomcombobox.h"
#include "zoomcombobox_p.h"

#include <KLocalizedString>
#include <QAbstractItemView>
#include <QAction>
#include <QEvent>
#include <QLineEdit>
#include <QSignalBlocker>
#include <QWheelEvent>

#include <cmath>

bool fuzzyEqual(qreal a, qreal b)
{
    return (qFuzzyIsNull(a) && qFuzzyIsNull(b)) || qFuzzyCompare(a, b);
}

bool fuzzyLessEqual(qreal a, qreal b)
{
    return fuzzyEqual(a, b) || a < b;
}

bool fuzzyGreaterEqual(qreal a, qreal b)
{
    return fuzzyEqual(a, b) || a > b;
}

using namespace Gwenview;

struct LineEditSelectionKeeper {
    LineEditSelectionKeeper(QLineEdit *lineEdit)
        : m_lineEdit(lineEdit)
    {
        Q_ASSERT(m_lineEdit);
        m_cursorPos = m_lineEdit->cursorPosition();
    }

    ~LineEditSelectionKeeper()
    {
        m_lineEdit->end(false);
        m_lineEdit->cursorBackward(true, m_lineEdit->text().length() - m_cursorPos);
    }

private:
    QLineEdit *m_lineEdit;
    int m_cursorPos;
};

ZoomValidator::ZoomValidator(qreal minimum, qreal maximum, ZoomComboBox *q, ZoomComboBoxPrivate *d, QWidget *parent)
    : QValidator(parent)
    , m_minimum(minimum)
    , m_maximum(maximum)
    , m_zoomComboBox(q)
    , m_zoomComboBoxPrivate(d)
{
}

ZoomValidator::~ZoomValidator() noexcept = default;

qreal ZoomValidator::minimum() const
{
    return m_minimum;
}

void ZoomValidator::setMinimum(const qreal minimum)
{
    if (fuzzyEqual(m_minimum, minimum)) {
        return;
    }
    m_minimum = minimum;
    Q_EMIT changed();
}

qreal ZoomValidator::maximum() const
{
    return m_maximum;
}

void ZoomValidator::setMaximum(const qreal maximum)
{
    if (fuzzyEqual(m_maximum, maximum)) {
        return;
    }
    m_maximum = maximum;
    Q_EMIT changed();
}

QValidator::State ZoomValidator::validate(QString &input, int &pos) const
{
    Q_UNUSED(pos)
    if (m_zoomComboBox->findText(input, Qt::MatchFixedString) > -1) {
        return QValidator::Acceptable;
    }

    QString copy = input.trimmed();
    copy.remove(locale().groupSeparator());
    copy.remove(locale().percent());
    const bool startsWithNumber = copy.constBegin()->isNumber();

    if (startsWithNumber || copy.isEmpty()) {
        return QValidator::Intermediate;
    }

    QValidator::State state;
    bool ok = false;
    int value = locale().toInt(copy, &ok);
    if (!ok || value < std::ceil(m_minimum * 100) || value > std::floor(m_maximum * 100)) {
        state = QValidator::Intermediate;
    } else {
        state = QValidator::Acceptable;
    }
    return state;
}

ZoomComboBoxPrivate::ZoomComboBoxPrivate(ZoomComboBox *q)
    : q_ptr(q)
    , validator(new ZoomValidator(0, 0, q, this, q))
{
}

ZoomComboBox::ZoomComboBox(QWidget *parent)
    : QComboBox(parent)
    , d_ptr(new ZoomComboBoxPrivate(this))
{
    Q_D(ZoomComboBox);

    d->validator->setObjectName(QLatin1String("zoomValidator"));
    setValidator(d->validator);

    setEditable(true);
    setInsertPolicy(QComboBox::NoInsert);
    // QLocale::percent() will return a QString in Qt 6.
    // Qt encourages using QString(locale().percent()) in QLocale documentation.
    const int percentLength = QString(locale().percent()).length();
    setMinimumContentsLength(locale().toString(9999).length() + percentLength);

    connect(lineEdit(), &QLineEdit::textEdited, this, [this, d](const QString &text) {
        const bool startsWithNumber = text.constBegin()->isNumber();
        int matchedIndex = -1;
        if (startsWithNumber) {
            matchedIndex = findText(text, Qt::MatchFixedString);
        } else {
            // check if there is more than 1 match
            for (int i = 0, n = count(); i < n; ++i) {
                if (itemText(i).startsWith(text, Qt::CaseInsensitive)) {
                    if (matchedIndex != -1) {
                        // there is more than 1 match
                        return;
                    }
                    matchedIndex = i;
                }
            }
        }
        if (matchedIndex != -1) {
            LineEditSelectionKeeper selectionKeeper(lineEdit());
            updateCurrentIndex();
            if (matchedIndex == currentIndex()) {
                updateDisplayedText();
            } else {
                activateAndChangeZoomTo(matchedIndex);
            }
        } else if (startsWithNumber) {
            bool ok = false;
            qreal value = valueFromText(text, &ok);
            if (ok && value > 0 && fuzzyLessEqual(value, maximum())) {
                // emulate autocompletion for valid values that aren't predefined
                while (value < minimum()) {
                    value *= 10;
                    if (value > maximum()) {
                        // autocompletion cannot be emulated for this value
                        return;
                    }
                }
                LineEditSelectionKeeper selectionKeeper(lineEdit());
                if (fuzzyEqual(value, d->value)) {
                    updateDisplayedText();
                } else {
                    d->lastCustomZoomValue = value;
                    activateAndChangeZoomTo(-1);
                }
            }
        }
    });
    connect(this, qOverload<int>(&ZoomComboBox::highlighted), this, &ZoomComboBox::changeZoomTo);
    view()->installEventFilter(this);
    connect(this, qOverload<int>(&ZoomComboBox::activated), this, &ZoomComboBox::activateAndChangeZoomTo);
}

ZoomComboBox::~ZoomComboBox() noexcept = default;

void ZoomComboBox::setActions(QAction *zoomToFitAction, QAction *zoomToFillAction, QAction *actualSizeAction)
{
    Q_D(ZoomComboBox);
    d->setActions(zoomToFitAction, zoomToFillAction, actualSizeAction);

    connect(zoomToFitAction, &QAction::toggled, this, &ZoomComboBox::updateDisplayedText);
    connect(zoomToFillAction, &QAction::toggled, this, &ZoomComboBox::updateDisplayedText);
}

void ZoomComboBoxPrivate::setActions(QAction *zoomToFitAction, QAction *zoomToFillAction, QAction *actualSizeAction)
{
    Q_Q(ZoomComboBox);
    q->clear();
    q->addItem(zoomToFitAction->iconText(), QVariant::fromValue(zoomToFitAction)); // index = 0
    q->addItem(zoomToFillAction->iconText(), QVariant::fromValue(zoomToFillAction)); // index = 1
    q->addItem(actualSizeAction->iconText(), QVariant::fromValue(actualSizeAction)); // index will change later

    mZoomToFitAction = zoomToFitAction;
    mZoomToFillAction = zoomToFillAction;
    mActualSizeAction = actualSizeAction;
}

qreal ZoomComboBox::value() const
{
    Q_D(const ZoomComboBox);
    return d->value;
}

void ZoomComboBox::setValue(qreal value)
{
    Q_D(ZoomComboBox);
    d->value = value;

    updateDisplayedText();
}

qreal ZoomComboBox::minimum() const
{
    Q_D(const ZoomComboBox);
    return d->validator->minimum();
}

void ZoomComboBox::setMinimum(qreal minimum)
{
    Q_D(ZoomComboBox);
    if (fuzzyEqual(this->minimum(), minimum)) {
        return;
    }
    d->validator->setMinimum(minimum);
    setValue(qMax(minimum, d->value));
    // Generate zoom presets below 100%
    // FIXME: combobox value gets reset to last index value when this code runs
    const int zoomToFillActionIndex = findData(QVariant::fromValue(d->mZoomToFillAction));
    const int actualSizeActionIndex = findData(QVariant::fromValue(d->mActualSizeAction));
    for (int i = actualSizeActionIndex - 1; i > zoomToFillActionIndex; --i) {
        removeItem(i);
    }
    qreal value = minimum * 2; // The minimum zoom value itself is already available through "fit".
    for (int i = zoomToFillActionIndex + 1; value < 1.0; ++i) {
        insertItem(i, textFromValue(value), QVariant::fromValue(value));
        value *= 2;
    }
}

qreal ZoomComboBox::maximum() const
{
    Q_D(const ZoomComboBox);
    return d->validator->maximum();
}

void ZoomComboBox::setMaximum(qreal maximum)
{
    Q_D(ZoomComboBox);
    if (fuzzyEqual(this->maximum(), maximum)) {
        return;
    }
    d->validator->setMaximum(maximum);
    setValue(qMin(d->value, maximum));
    // Generate zoom presets above 100%
    // NOTE: This probably has the same problem as setMinimum(),
    // but the problem is never enountered since max zoom doesn't actually change
    const int actualSizeActionIndex = findData(QVariant::fromValue(d->mActualSizeAction));
    const int count = this->count();
    for (int i = actualSizeActionIndex + 1; i < count; ++i) {
        removeItem(i);
    }
    qreal value = 2.0;
    while (value < maximum) {
        addItem(textFromValue(value), QVariant::fromValue(value));
        value *= 2;
    }
    if (fuzzyGreaterEqual(value, maximum)) {
        addItem(textFromValue(maximum), QVariant::fromValue(maximum));
    }
}

qreal ZoomComboBox::valueFromText(const QString &text, bool *ok) const
{
    Q_D(const ZoomComboBox);

    const QLocale l = locale();
    QString s = text;
    s.remove(l.groupSeparator());

    if (s.endsWith(l.percent())) {
        s = s.chopped(1);
    }

    if (s.startsWith(l.percent())) {
        s = s.remove(0, 1);
    }

    return l.toDouble(s, ok) / 100.0;
}

QString ZoomComboBox::textFromValue(const qreal value) const
{
    Q_D(const ZoomComboBox);

    QLocale l = locale();
    l.setNumberOptions(QLocale::OmitGroupSeparator);

    QString formattedValue = l.toString(qRound(value * 100));
    return i18nc("Percent value", "%1%", formattedValue);
}

void ZoomComboBox::updateDisplayedText()
{
    Q_D(ZoomComboBox);
    if (d->mZoomToFitAction->isChecked()) {
        lineEdit()->setText(d->mZoomToFitAction->iconText());
    } else if (d->mZoomToFillAction->isChecked()) {
        lineEdit()->setText(d->mZoomToFillAction->iconText());
    } else if (d->mActualSizeAction->isChecked()) {
        lineEdit()->setText(d->mActualSizeAction->iconText());
    } else {
        lineEdit()->setText(textFromValue(d->value));
    }
}

void Gwenview::ZoomComboBox::showPopup()
{
    updateCurrentIndex();

    // We don't want to emit a QComboBox::highlighted event just because the popup is opened.
    const QSignalBlocker blocker(this);
    QComboBox::showPopup();
}

bool ZoomComboBox::eventFilter(QObject *watched, QEvent *event)
{
    if (watched == view()) {
        switch (event->type()) {
        case QEvent::Hide: {
            Q_D(ZoomComboBox);
            changeZoomTo(d->lastSelectedIndex);
            break;
        }
        case QEvent::ShortcutOverride: {
            if (view()->isVisibleTo(this)) {
                auto keyEvent = static_cast<QKeyEvent *>(event);
                if (keyEvent->key() == Qt::Key_Escape) {
                    event->accept();
                }
            }
            break;
        }
        default:
            break;
        }
    }

    return QComboBox::eventFilter(watched, event);
}

void ZoomComboBox::focusOutEvent(QFocusEvent *event)
{
    Q_D(ZoomComboBox);
    // Should the user have started typing a custom value
    // that was out of our range, then we have a temporary
    // state that is illegal. This is needed to allow a user
    // to type a zoom with multiple keystrokes, but when the
    // user leaves focus we should reset to the last known 'good'
    // zoom value.
    if (d->lastSelectedIndex == -1)
        setValue(d->lastCustomZoomValue);

    QComboBox::focusOutEvent(event);
}

void ZoomComboBox::keyPressEvent(QKeyEvent *event)
{
    switch (event->key()) {
    case Qt::Key_Down:
    case Qt::Key_Up:
    case Qt::Key_PageDown:
    case Qt::Key_PageUp: {
        updateCurrentIndex();
        if (currentIndex() != -1) {
            break;
        }
        moveCurrentIndex(event->key() == Qt::Key_Down || event->key() == Qt::Key_PageDown);
        return;
    }
    default:
        break;
    }

    QComboBox::keyPressEvent(event);
}

void ZoomComboBox::wheelEvent(QWheelEvent *event)
{
    updateCurrentIndex();
    if (currentIndex() != -1) {
        // Everything should work as expected.
        QComboBox::wheelEvent(event);
        return;
    }

    moveCurrentIndex(event->angleDelta().y() < 0);
}

void ZoomComboBox::updateCurrentIndex()
{
    Q_D(ZoomComboBox);

    if (d->mZoomToFitAction->isChecked()) {
        setCurrentIndex(0);
        d->lastSelectedIndex = 0;
    } else if (d->mZoomToFillAction->isChecked()) {
        setCurrentIndex(1);
        d->lastSelectedIndex = 1;
    } else if (d->mActualSizeAction->isChecked()) {
        const int actualSizeActionIndex = findData(QVariant::fromValue(d->mActualSizeAction));
        setCurrentIndex(actualSizeActionIndex);
        d->lastSelectedIndex = actualSizeActionIndex;
    } else {
        // Now is a good time to save the zoom value that was selected before the user changes it through the popup.
        d->lastCustomZoomValue = d->value;

        // Highlight the correct index if the current zoom value exists as an option in the popup.
        // If it doesn't exist, it is set to -1.
        d->lastSelectedIndex = findText(textFromValue(d->value));
        setCurrentIndex(d->lastSelectedIndex);
    }
}

void ZoomComboBox::moveCurrentIndex(bool moveUp)
{
    // There is no exact match for the current zoom value in the
    // ComboBox. We need to find the closest matches, so scrolling
    // works as expected.
    Q_D(ZoomComboBox);

    int newIndex;
    if (moveUp) {
        // switch to a larger item
        newIndex = count() - 1;
        for (int i = 2; i < newIndex; ++i) {
            const QVariant data = itemData(i);
            qreal value;
            if (data.value<QAction *>() == d->mActualSizeAction) {
                value = 1;
            } else {
                value = data.value<qreal>();
            }
            if (value > d->value) {
                newIndex = i;
                break;
            }
        }
    } else {
        // switch to a smaller item
        newIndex = 1;
        for (int i = count() - 1; i > newIndex; --i) {
            const QVariant data = itemData(i);
            qreal value;
            if (data.value<QAction *>() == d->mActualSizeAction) {
                value = 1;
            } else {
                value = data.value<qreal>();
            }
            if (value < d->value) {
                newIndex = i;
                break;
            }
        }
    }
    setCurrentIndex(newIndex);
    Q_EMIT activated(newIndex);
}

void ZoomComboBox::changeZoomTo(int index)
{
    if (index < 0) {
        Q_D(ZoomComboBox);
        Q_EMIT zoomChanged(d->lastCustomZoomValue);
        return;
    }

    QVariant itemData = this->itemData(index);
    auto action = itemData.value<QAction *>();
    if (action) {
        if (!action->isCheckable() || !action->isChecked()) {
            action->trigger();
        }
    } else if (itemData.canConvert(QMetaType::QReal)) {
        Q_EMIT zoomChanged(itemData.toReal());
    }
}

void ZoomComboBox::activateAndChangeZoomTo(int index)
{
    Q_D(ZoomComboBox);
    d->lastSelectedIndex = index;

    // The user has explicitly selected this zoom value so we
    // remember it the same way as if they had typed it themselves.
    QVariant itemData = this->itemData(index);
    if (!itemData.value<QAction *>() && itemData.canConvert(QMetaType::QReal)) {
        d->lastCustomZoomValue = itemData.toReal();
    }

    changeZoomTo(index);
}

#include "moc_zoomcombobox.cpp"

#include "moc_zoomcombobox_p.cpp"