kwidget.h

Go to the documentation of this file.

/****************************************************************************
**
** This file is part of KDWinutils, KDAB's MFC to Qt migration tool.
**
** Copyright (C) 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
** All rights reserved.
**
** This file is intended solely for use by the migration tools and services
** provided by Klarälvdalens Datakonsult AB.
**
**  Any other use or distribution of this software that is not otherwise agreed
**  upon in writing and signed by an authorized representative of Klarälvdalens
**  Datakonsult AB, KDAB (USA) LLC, KDAB (Deutschland) GmbH & Co. K.G.,
**  KDAB (France) SAS, KDAB (UK), Ltd., or any future subsidiary of Klarälvdalens
**  Datakonsult AB is hereby prohibited.
**
**  Contact info@kdab.com if any conditions stated above are unclear to you.
**
****************************************************************************/
 
#pragma once
 
#include "../corelib/krect.h"
#include "../corelib/kstring.h"
#include "../kdwinutils_global.h"
 
#include <QAbstractScrollArea>
#include <QAbstractSlider>
#include <QCoreApplication>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QScrollBar>
#include <QVBoxLayout>
#include <QWidget>
 
#include <functional>
#include <optional>
#include <unordered_map>
 
#ifdef KDWINUTILS_WITHMFC
#include <afxwin.h>
#endif
 
KDWINUTILS_BEGIN_NAMESPACE
 
class KWidget;
class KDialog;
 
constexpr char InternalScrollAreaName[] = "InternalScroll";
 
class KMessageEvent : public QEvent
{
public:
    explicit KMessageEvent(unsigned int messageId, uint64_t w, int64_t l)
        : QEvent(static_cast<QEvent::Type>(KMessageEvent::Type))
        , id(messageId)
        , wparam(w)
        , lparam(l)
    {
    }
 
    enum {
        Type = QEvent::User + 45687,
    };
 
    unsigned int id;
    uint64_t wparam;
    int64_t lparam;
};
 
template <typename T>
class KWidgetBase : public T
{
public:
    using T::T;
    ~KWidgetBase<T>();
 
    static constexpr char mfcIDProperty[] = "mfc_id";
 
    bool eventFilter(QObject *watched, QEvent *event) override;
 
    enum class Flag {
        NoFlags = 0x0000, 
        VScroll = 0x0001, 
        HScroll = 0x0002, 
        HelpInfo = 0x0004, 
    };
    Q_DECLARE_FLAGS(Flags, Flag)
    void setFlag(Flag flag, bool on = true);
 
    virtual bool Create(const KString &lpszWindowName, Flags dwStyle, const KRect &rect, QWidget *pParentWnd);
 
    bool PostMessage(unsigned int id, uint64_t wParam = 0, int64_t lParam = 0);
 
    int64_t SendMessage(unsigned int id, uint64_t wParam = 0, int64_t lParam = 0);
 
    void DestroyWindow();
 
    template <typename U>
    U GetParent() const;
 
    template <typename U = T>
    KWidget *GetParentWidget() const;
 
    template <typename U = T>
    KDialog *GetParentDialog() const;
 
    void GetClientRect(KRect *rect) const;
    void GetWindowRect(KRect *rect) const;
 
    enum class ScrollMask : uint {
        Range = 0x0001, 
        Page = 0x0002, 
        Pos = 0x0004, 
        DisableNoScroll = 0x0008, 
        TrackPos = 0x0010, 
        All = Range | Page | Pos | TrackPos, 
    };
    Q_DECLARE_FLAGS(ScrollMasks, ScrollMask)
 
    
    struct ScrollInfo
    {
        ScrollMasks fMask;
        int nMin = -1;
        int nMax = -1;
        unsigned int nPage = -1;
        int nPos = -1;
        int nTrackPos = -1;
    };
 
    bool GetScrollInfo(Qt::Orientation nBar, ScrollInfo *lpScrollInfo, ScrollMasks nMask = ScrollMask::All);
    int GetScrollLimit(Qt::Orientation nBar);
    int GetScrollPos(Qt::Orientation nBar) const;
    void GetScrollRange(Qt::Orientation nBar, int *lpMinPos, int *lpMaxPos) const;
    bool SetScrollInfo(Qt::Orientation nBar, ScrollInfo *lpScrollInfo, bool bRedraw = true);
    int SetScrollPos(Qt::Orientation nBar, int nPos, bool bRedraw = true);
    void SetScrollRange(Qt::Orientation nBar, int nMinPos, int nMaxPos, bool bRedraw = true);
 
    virtual void OnHelp() { }
 
protected:
    using MessageHandler = std::function<int64_t(uint64_t, int64_t)>;
    void connectMessage(int id, MessageHandler method);
    template <typename Class>
    void connectMessage(int id, Class *object, int64_t (Class::*method)(uint64_t, int64_t));
 
    using FocusHandler = std::function<void()>;
    void connectKillFocus(QWidget *w, FocusHandler method);
    template <typename Class>
    void connectKillFocus(QWidget *w, Class *object, void (Class::*method)());
 
    void connectScroll(QAbstractSlider *abstractSlider);
    template <typename Signal, typename Class>
    void connectRange(const typename QtPrivate::FunctionPointer<Signal>::Object *firstWidget,
                      const typename QtPrivate::FunctionPointer<Signal>::Object *lastWidget, Signal signal,
                      Class *object, void (Class::*method)(unsigned int));
 
    virtual bool OnHelpInfo(QKeyEvent *event) { return false; }
 
    virtual void OnLButtonDblClk(QMouseEvent *event) { }
    virtual void OnLButtonDown(QMouseEvent *event) { }
    virtual void OnLButtonUp(QMouseEvent *event) { }
    virtual void OnMButtonDblClk(QMouseEvent *event) { }
    virtual void OnMButtonDown(QMouseEvent *event) { }
    virtual void OnMButtonUp(QMouseEvent *event) { }
    virtual void OnRButtonDblClk(QMouseEvent *event) { }
    virtual void OnRButtonDown(QMouseEvent *event) { }
    virtual void OnRButtonUp(QMouseEvent *event) { }
    virtual void OnMouseMove(QMouseEvent *event) { }
 
    virtual void OnKeyDown(QKeyEvent *event) { }
    virtual void OnKeyUp(QKeyEvent *event) { }
 
    virtual void OnPaint(QPaintEvent *event);
 
    virtual void OnHScroll(int nSBCode, int nPos, QAbstractSlider *pScroll) { }
    virtual void OnVScroll(int nSBCode, int nPos, QAbstractSlider *pScroll) { }
 
    virtual void OnDestroy() { }
 
    virtual void OnSize(QResizeEvent *event) { }
 
    void mousePressEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void paintEvent(QPaintEvent *event) override;
    void keyPressEvent(QKeyEvent *event) override;
    void keyReleaseEvent(QKeyEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;
    bool event(QEvent *e) override;
 
private:
    friend class KPainter;
 
    std::optional<int64_t> handleMessageEvent(unsigned int id, uint64_t wparam, int64_t lparam);
    void handleFocusEvent(QObject *id);
    QAbstractScrollArea *scrollArea() const;
    QScrollBar *scrollBar(Qt::Orientation nBar) const;
 
    std::unordered_map<unsigned int, MessageHandler> m_messageHandlers;
    std::unordered_map<QObject *, FocusHandler> m_focusHandlers;
    int64_t m_messageResult;
    Flags m_flags;
};
 
class KDWINUTILS_EXPORT KWidget : public KWidgetBase<QWidget>
{
    Q_OBJECT
public:
    using KWidgetBase<QWidget>::KWidgetBase;
};
 
// KWidgetBase method implementations
template <typename T>
KWidgetBase<T>::~KWidgetBase()
{
    OnDestroy();
}
 
template <typename T>
bool KWidgetBase<T>::eventFilter(QObject *watched, QEvent *event)
{
    if (watched->objectName() == InternalScrollAreaName && event->type() == QEvent::Paint) {
        auto paintEvent = static_cast<QPaintEvent *>(event);
        OnPaint(paintEvent);
    }
    if (event->type() == QEvent::FocusOut) {
        handleFocusEvent(watched);
    }
    return T::eventFilter(watched, event);
}
 
template <typename T>
void KWidgetBase<T>::setFlag(Flag flag, bool on)
{
    m_flags.setFlag(flag, on);
}
 
template <typename T>
bool KWidgetBase<T>::Create(const KString &lpszWindowName, Flags dwStyle, const KRect &rect, QWidget *pParentWnd)
{
    m_flags |= dwStyle;
 
    if (dwStyle.testAnyFlags({Flag::HScroll, Flag::VScroll})) {
        auto scrollArea = new QAbstractScrollArea(this);
        scrollArea->setObjectName(InternalScrollAreaName);
        scrollArea->setFrameShape(QFrame::NoFrame);
        scrollArea->setLineWidth(0);
        auto layout = new QHBoxLayout(this);
        layout->addWidget(scrollArea);
        layout->setContentsMargins({});
        connectScroll(scrollArea->horizontalScrollBar());
        connectScroll(scrollArea->verticalScrollBar());
        if (!dwStyle.testAnyFlag(Flag::HScroll))
            scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        if (!dwStyle.testAnyFlag(Flag::VScroll))
            scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        scrollArea->viewport()->setObjectName(InternalScrollAreaName);
        scrollArea->viewport()->installEventFilter(this);
    }
 
    T::setParent(pParentWnd);
    T::setGeometry(rect);
 
    return true;
}
 
template <typename T>
bool KWidgetBase<T>::PostMessage(unsigned int id, uint64_t wParam, int64_t lParam)
{
    auto message = new KMessageEvent(id, wParam, lParam);
    QCoreApplication::postEvent(this, message);
    return true;
}
 
template <typename T>
int64_t KWidgetBase<T>::SendMessage(unsigned int id, uint64_t wParam, int64_t lParam)
{
    auto message = KMessageEvent(id, wParam, lParam);
    QCoreApplication::sendEvent(this, &message);
    return m_messageResult;
}
 
template <typename T>
void KWidgetBase<T>::DestroyWindow()
{
    T::deleteLater();
}
 
template <typename T>
template <typename U>
U KWidgetBase<T>::GetParent() const
{
    return dynamic_cast<U>(T::parent());
}
 
template <typename T>
template <typename U>
inline KWidget *KWidgetBase<T>::GetParentWidget() const
{
    return qobject_cast<KWidget *>(T::parent());
}
 
template <typename T>
void KWidgetBase<T>::GetClientRect(KRect *rect) const
{
    if (m_flags.testAnyFlags({Flag::HScroll, Flag::VScroll})) {
        const auto &viewportRect = scrollArea()->viewport()->rect();
        *rect = viewportRect;
    } else {
        rect->SetRect(0, 0, T::width(), T::height());
    }
}
 
template <typename T>
void KWidgetBase<T>::GetWindowRect(KRect *rect) const
{
    const auto &geom = T::frameGeometry();
    rect->SetRect(T::x(), T::y(), geom.width(), geom.height());
}
 
template <typename T>
bool KWidgetBase<T>::GetScrollInfo(Qt::Orientation nBar, ScrollInfo *lpScrollInfo, ScrollMasks nMask)
{
    auto sb = scrollBar(nBar);
    if (nMask.testFlag(ScrollMask::Range)) {
        lpScrollInfo->nMin = sb->minimum();
        lpScrollInfo->nMax = sb->maximum();
    }
    if (nMask.testFlag(ScrollMask::Page))
        lpScrollInfo->nPage = sb->pageStep();
    if (nMask.testFlag(ScrollMask::Pos))
        lpScrollInfo->nPos = sb->value();
    if (nMask.testFlag(ScrollMask::TrackPos))
        lpScrollInfo->nTrackPos = sb->sliderPosition();
    lpScrollInfo->fMask = nMask;
    return true;
}
 
template <typename T>
int KWidgetBase<T>::GetScrollLimit(Qt::Orientation nBar)
{
    return scrollBar(nBar)->maximum();
}
 
template <typename T>
int KWidgetBase<T>::GetScrollPos(Qt::Orientation nBar) const
{
    return scrollBar(nBar)->value();
}
 
template <typename T>
void KWidgetBase<T>::GetScrollRange(Qt::Orientation nBar, int *lpMinPos, int *lpMaxPos) const
{
    *lpMinPos = scrollBar(nBar)->minimum();
    *lpMaxPos = scrollBar(nBar)->maximum();
}
 
template <typename T>
bool KWidgetBase<T>::SetScrollInfo(Qt::Orientation nBar, ScrollInfo *lpScrollInfo, bool /*bRedraw*/)
{
    auto sb = scrollBar(nBar);
    if (lpScrollInfo->fMask.testFlag(ScrollMask::Range))
        sb->setRange(lpScrollInfo->nMin, lpScrollInfo->nMax);
    if (lpScrollInfo->fMask.testFlag(ScrollMask::Page))
        sb->setPageStep(lpScrollInfo->nPage);
    if (lpScrollInfo->fMask.testFlag(ScrollMask::TrackPos) && lpScrollInfo->nTrackPos != -1)
        sb->setSliderPosition(lpScrollInfo->nTrackPos);
    if (lpScrollInfo->fMask.testFlag(ScrollMask::Pos))
        sb->setValue(lpScrollInfo->nPos);
    if (lpScrollInfo->fMask.testFlag(ScrollMask::DisableNoScroll)) {
        switch (nBar) {
        case Qt::Horizontal:
            scrollArea()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
        case Qt::Vertical:
            scrollArea()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
        }
    }
    return true;
}
 
template <typename T>
int KWidgetBase<T>::SetScrollPos(Qt::Orientation nBar, int nPos, bool /*bRedraw*/)
{
    const int oldValue = scrollBar(nBar)->value();
    scrollBar(nBar)->setValue(nPos);
    return oldValue;
}
 
template <typename T>
void KWidgetBase<T>::SetScrollRange(Qt::Orientation nBar, int nMinPos, int nMaxPos, bool /*bRedraw*/)
{
    scrollBar(nBar)->setRange(nMinPos, nMaxPos);
}
 
template <typename T>
void KWidgetBase<T>::connectMessage(int id, MessageHandler method)
{
    m_messageHandlers[id] = method;
}
 
template <typename T>
void KWidgetBase<T>::handleFocusEvent(QObject *id)
{
    auto it = m_focusHandlers.find(id);
    if (it != m_focusHandlers.end()) {
        it->second;
    }
}
 
template <typename T>
template <typename Class>
void KWidgetBase<T>::connectMessage(int id, Class *object, int64_t (Class::*method)(uint64_t, int64_t))
{
    connectMessage(id, [object, method](uint64_t wParam, int64_t lParam) {
        return (object->*method)(wParam, lParam);
    });
}
 
template <typename T>
void KWidgetBase<T>::connectKillFocus(QWidget *w, FocusHandler method)
{
    m_focusHandlers[w] = method;
    w->installEventFilter(this);
}
 
template <typename T>
template <typename Class>
void KWidgetBase<T>::connectKillFocus(QWidget *w, Class *object, void (Class::*method)())
{
    connectKillFocus(w, [object, method]() {
        return (object->*method)();
    });
}
 
template <typename T>
void KWidgetBase<T>::connectScroll(QAbstractSlider *abstractSlider)
{
    auto callback = [abstractSlider, this](int action) {
        if (abstractSlider->orientation() == Qt::Horizontal)
            OnHScroll(action, abstractSlider->sliderPosition(), abstractSlider);
        else
            OnVScroll(action, abstractSlider->sliderPosition(), abstractSlider);
    };
    T::connect(abstractSlider, &QAbstractSlider::actionTriggered, this, callback);
}
 
template <typename T>
template <typename Signal, typename Class>
inline void KWidgetBase<T>::connectRange(const typename QtPrivate::FunctionPointer<Signal>::Object *firstWidget,
                                         const typename QtPrivate::FunctionPointer<Signal>::Object *lastWidget,
                                         Signal signal, Class *object, void (Class::*method)(unsigned int))
{
    const int firstId = firstWidget->property(mfcIDProperty).toInt();
    const int lastId = lastWidget->property(mfcIDProperty).toInt();
    if (firstId == 0 || lastId == 0)
        return;
    auto widgets = T::template findChildren<QWidget *>();
    for (auto widget : widgets) {
        const int id = widget->property(mfcIDProperty).toInt();
        if (id >= firstId && id <= lastId) {
            T::connect(dynamic_cast<typename QtPrivate::FunctionPointer<Signal>::Object *>(widget), signal, object,
                       [object, method, id] {
                           (object->*method)(id);
                       });
        }
    }
}
 
template <typename T>
void KWidgetBase<T>::OnPaint(QPaintEvent *event)
{
    T::paintEvent(event);
}
 
template <typename T>
void KWidgetBase<T>::mousePressEvent(QMouseEvent *event)
{
    switch (event->button()) {
    case Qt::LeftButton:
        OnLButtonDown(event);
        break;
    case Qt::MiddleButton:
        OnMButtonDown(event);
        break;
    case Qt::RightButton:
        OnRButtonDown(event);
        break;
    default:
        break;
    }
    T::mousePressEvent(event);
}
 
template <typename T>
void KWidgetBase<T>::mouseReleaseEvent(QMouseEvent *event)
{
    switch (event->button()) {
    case Qt::LeftButton:
        OnLButtonUp(event);
        break;
    case Qt::MiddleButton:
        OnMButtonUp(event);
        break;
    case Qt::RightButton:
        OnRButtonUp(event);
        break;
    default:
        break;
    }
    T::mouseReleaseEvent(event);
}
 
template <typename T>
void KWidgetBase<T>::mouseDoubleClickEvent(QMouseEvent *event)
{
    switch (event->button()) {
    case Qt::LeftButton:
        OnLButtonDblClk(event);
        break;
    case Qt::MiddleButton:
        OnMButtonDblClk(event);
        break;
    case Qt::RightButton:
        OnRButtonDblClk(event);
        break;
    default:
        break;
    }
    T::mouseDoubleClickEvent(event);
}
 
template <typename T>
inline void KWidgetBase<T>::mouseMoveEvent(QMouseEvent *event)
{
    OnMouseMove(event);
    T::mouseMoveEvent(event);
}
 
template <typename T>
void KWidgetBase<T>::paintEvent(QPaintEvent *event)
{
    // Do nothing if there's a scroll area (the widget is behind it anyway)
    // Painting is done inside the eventFilter, on the viewport of the scrollArea
    if (m_flags.testAnyFlags({Flag::HScroll, Flag::VScroll}))
        return;
    OnPaint(event);
}
 
template <typename T>
void KWidgetBase<T>::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_F1 && event->modifiers() == Qt::NoModifier && m_flags.testFlag(Flag::HelpInfo)) {
        OnHelpInfo(event);
        OnHelp();
    }
    OnKeyDown(event);
    T::keyPressEvent(event);
}
 
template <typename T>
inline void KWidgetBase<T>::keyReleaseEvent(QKeyEvent *event)
{
    OnKeyUp(event);
    T::keyReleaseEvent(event);
}
 
template <typename T>
inline void KWidgetBase<T>::resizeEvent(QResizeEvent *event)
{
    T::resizeEvent(event);
    OnSize(event);
}
 
template <typename T>
bool KWidgetBase<T>::event(QEvent *e)
{
    if (e->type() == static_cast<QEvent::Type>(KMessageEvent::Type)) {
        auto message = static_cast<KMessageEvent *>(e);
        auto result = handleMessageEvent(message->id, message->wparam, message->lparam);
        m_messageResult = result.value_or(0);
        return result.has_value();
    }
    return T::event(e);
}
 
template <typename T>
std::optional<int64_t> KWidgetBase<T>::handleMessageEvent(unsigned int id, uint64_t wparam, int64_t lparam)
{
    auto it = m_messageHandlers.find(id);
    if (it == m_messageHandlers.end())
        return {};
    return it->second(wparam, lparam);
}
 
template <typename T>
QAbstractScrollArea *KWidgetBase<T>::scrollArea() const
{
    return T::template findChild<QAbstractScrollArea *>(InternalScrollAreaName, Qt::FindDirectChildrenOnly);
}
 
template <typename T>
QScrollBar *KWidgetBase<T>::scrollBar(Qt::Orientation nBar) const
{
    switch (nBar) {
    case Qt::Horizontal:
        return scrollArea()->horizontalScrollBar();
    case Qt::Vertical:
        return scrollArea()->verticalScrollBar();
    }
    return nullptr;
}
 
KDWINUTILS_END_NAMESPACE