weffectselector.cpp

#include "widget/weffectselector.h"

#include <QAbstractItemView>
#include <QGuiApplication>
#include <QScreen>
#include <QStyledItemDelegate>
#include <QtDebug>

#include "effects/effectsmanager.h"
#include "effects/visibleeffectslist.h"
#include "moc_weffectselector.cpp"
#include "widget/effectwidgetutils.h"

namespace {

constexpr int kTouchEffectRowHeight = 56;
constexpr int kTouchEffectPopupWidth = 420;

class TouchEffectItemDelegate final : public QStyledItemDelegate {
  public:
    explicit TouchEffectItemDelegate(QObject* pParent)
            : QStyledItemDelegate(pParent) {
    }

    QSize sizeHint(const QStyleOptionViewItem& option,
            const QModelIndex& index) const override {
        QSize size = QStyledItemDelegate::sizeHint(option, index);
        size.setHeight(qMax(size.height(), kTouchEffectRowHeight));
        size.setWidth(qMax(size.width(), kTouchEffectPopupWidth));
        return size;
    }
};

} // namespace

WEffectSelector::WEffectSelector(QWidget* pParent, EffectsManager* pEffectsManager)
        : QComboBox(pParent),
          WBaseWidget(this),
          m_pEffectsManager(pEffectsManager),
          m_pVisibleEffectsList(pEffectsManager->getVisibleEffectsList()) {
    // Prevent this widget from getting focused by Tab/Shift+Tab
    // to avoid interfering with using the library via keyboard.
    // Allow click focus though so the list can always be opened by mouse,
    // see https://github.com/mixxxdj/mixxx/issues/10184
    setFocusPolicy(Qt::ClickFocus);

    // The BiteDJ side panel is intentionally compact, but the selector popup
    // must not inherit that tiny geometry. Give every effect a finger-sized
    // row. Do not install a QScroller gesture here: on the Pi touchscreen it
    // consumes the release event, which lets the list move but prevents the
    // tapped effect from being activated.
    setItemDelegate(new TouchEffectItemDelegate(this));
    setMaxVisibleItems(8);
    view()->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
    view()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
}

void WEffectSelector::showPopup() {
    const QScreen* pScreen = QGuiApplication::screenAt(
            mapToGlobal(rect().center()));
    const int availableWidth = pScreen != nullptr
            ? pScreen->availableGeometry().width()
            : kTouchEffectPopupWidth;
    const int availableHeight = pScreen != nullptr
            ? pScreen->availableGeometry().height()
            : kTouchEffectRowHeight * 8;

    const int popupWidth = qMin(
            qMax(width(), kTouchEffectPopupWidth),
            qMax(width(), availableWidth - 24));
    view()->setMinimumWidth(popupWidth);
    view()->setMaximumWidth(popupWidth);

    // Keep the popup on-screen on smaller Mako-class displays while showing
    // up to eight effects at once on the 10-inch Touch Display 2.
    setMaxVisibleItems(qBound(4,
            (availableHeight - 48) / kTouchEffectRowHeight,
            8));

    QComboBox::showPopup();
}

void WEffectSelector::setup(const QDomNode& node, const SkinContext& context) {
    // EffectWidgetUtils propagates NULLs so this is all safe.
    EffectChainPointer pChainSlot = EffectWidgetUtils::getEffectChainFromNode(
            node, context, m_pEffectsManager);
    m_pEffectSlot = EffectWidgetUtils::getEffectSlotFromNode(
            node, context, pChainSlot);

    if (m_pEffectSlot != nullptr) {
        connect(m_pVisibleEffectsList.data(),
                &VisibleEffectsList::visibleEffectsListChanged,
                this,
                &WEffectSelector::populate);
        connect(m_pEffectSlot.data(),
                &EffectSlot::effectChanged,
                this,
                &WEffectSelector::slotEffectUpdated);
        connect(this,
                QOverload<int>::of(&QComboBox::activated),
                this,
                &WEffectSelector::slotEffectSelected);
    } else {
        SKIN_WARNING(node,
                context,
                QStringLiteral("EffectSelector node could not attach to effect "
                               "slot."));
    }

    populate();
}

void WEffectSelector::populate() {
    blockSignals(true);
    clear();

    const QList<EffectManifestPointer> visibleEffectManifests = m_pVisibleEffectsList->getList();
    // Add empty item: no effect
    addItem(kNoEffectString);
    setItemData(0, QVariant(tr("No effect loaded.")), Qt::ToolTipRole);

    for (int i = 0; i < visibleEffectManifests.size(); ++i) {
        const EffectManifestPointer pManifest = visibleEffectManifests.at(i);
        // Keep the complete name in the model. The closed combo clips it to
        // the compact side panel, while the widened popup can show it whole.
        addItem(pManifest->displayName(), QVariant(pManifest->uniqueId()));

        QString name = pManifest->name();
        QString description = pManifest->description();
        // <b> makes the effect name bold. Also, like <span> it serves as hack
        // to get Qt to treat the string as rich text so it automatically wraps long lines.
        setItemData(i + 1,
                QVariant(QStringLiteral("<b>") + name +
                        QStringLiteral("</b><br/>") + description),
                Qt::ToolTipRole);
    }

    slotEffectUpdated();
    blockSignals(false);
}

void WEffectSelector::slotEffectSelected(int newIndex) {
    const EffectManifestPointer pManifest =
            m_pEffectsManager->getBackendManager()->getManifestFromUniqueId(
                    itemData(newIndex).toString());

    // Bite DJ fork: route through the per-manifest cache so the BeatFX
    // picker preserves user knob/metaknob state across effect switches.
    // Standard chains opt in; EQ/QuickEffect/Output fall through to
    // loadEffectWithDefaults internally.
    m_pEffectSlot->switchEffectRemembering(pManifest);

    setBaseTooltip(itemData(newIndex, Qt::ToolTipRole).toString());
    // Clicking an effect item moves keyboard focus to the list view.
    // Move focus back to the previously focused library widget.
    ControlObject::set(ConfigKey("[Library]", "refocus_prev_widget"), 1);
}

void WEffectSelector::slotEffectUpdated() {
    int newIndex;

    if (m_pEffectSlot != nullptr) {
        if (m_pEffectSlot->getManifest() != nullptr) {
            EffectManifestPointer pManifest = m_pEffectSlot->getManifest();
            newIndex = findData(QVariant(pManifest->uniqueId()));
        } else {
            newIndex = findData(QVariant());
        }
    } else {
        newIndex = findData(QVariant());
    }

    if (kEffectDebugOutput) {
        qDebug() << "WEffectSelector::slotEffectUpdated"
                 << "old" << itemData(currentIndex())
                 << "new" << itemData(newIndex);
    }

    if (newIndex != -1 && newIndex != currentIndex()) {
        setCurrentIndex(newIndex);
        setBaseTooltip(itemData(newIndex, Qt::ToolTipRole).toString());
    }
}

bool WEffectSelector::event(QEvent* pEvent) {
    if (pEvent->type() == QEvent::ToolTip) {
        updateTooltip();
    } else if (pEvent->type() == QEvent::Wheel && !hasFocus()) {
        // don't change effect by scrolling hovered effect selector
        return true;
    }

    return QComboBox::event(pEvent);
}