klistmodel.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 "../kdwinutils_global.h"
 
#include "../corelib/kdwincore_impl.h"
#include "../corelib/krect.h"
#include "../corelib/kstring.h"
#include "../widgets/ksortfilterproxymodel.h"
 
#include <QAbstractItemModel>
#include <QFlags>
 
#include <memory>
 
class QAbstractItemDelegate;
class QHelpEvent;
class QPainter;
class QStyleOptionViewItem;
class QTreeView;
 
KDWINUTILS_BEGIN_NAMESPACE
 
class StyledItemDelegate;
class KDialog;
class KHeaderCtrl;
class KImageList;
class KItemViewToolTipHandler;
 
class KDWINUTILS_EXPORT KListModel : public QAbstractItemModel
{
    Q_OBJECT
 
public:
    explicit KListModel(QObject *parent = nullptr);
    ~KListModel();
 
    QTreeView *widget() const;
    void setWidget(QTreeView *widget);
 
    // QAbstractItemModel
    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
    QModelIndex parent(const QModelIndex &child) const override;
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    bool setData(const QModelIndex &index, const QVariant &value, int role) override;
    bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
 
    QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
    QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;
 
    Qt::Alignment getColumnAlignment(int col) const;
 
#ifdef KDWINUTILS_WITHMFC
    static Qt::AlignmentFlag toQtAlignmentFlag(int nFormat);
#endif // KDWINUTILS_WITHMFC
 
    using CustomPaintFunction = std::function<void(QPainter *, const QStyleOptionViewItem &, const QModelIndex &)>;
    void setCustomPaintFunction(const CustomPaintFunction &function);
    template <typename Class>
    void setCustomPaintFunction(Class *object,
                                void (Class::*method)(QPainter *painter, const QStyleOptionViewItem &styleOption,
                                                      const QModelIndex &index));
 
    struct Position
    {
        Position() = default;
        explicit Position(int p) noexcept
            : pos(p) {};
 
        explicit operator bool() const noexcept { return pos >= 0; }
 
        friend inline bool operator==(Position lhs, Position rhs) noexcept { return lhs.pos == rhs.pos; }
        friend inline bool operator!=(Position lhs, Position rhs) noexcept { return lhs.pos != rhs.pos; }
 
        friend inline bool operator==(Position p, Private::CompareAgainstLiteralZero) noexcept
        {
            return !static_cast<bool>(p);
        }
        friend inline bool operator!=(Position p, Private::CompareAgainstLiteralZero) noexcept
        {
            return static_cast<bool>(p);
        }
 
        friend inline bool operator==(Position p, std::nullptr_t) noexcept { return !static_cast<bool>(p); }
        friend inline bool operator!=(Position p, std::nullptr_t) noexcept { return static_cast<bool>(p); }
 
        int pos = -1;
    };
 
    enum class Style : uint {
        Icon = 0x00000001, 
        Report = 0x00000002, 
        SmallIcon = 0x00000004, 
        List = 0x00000008, 
        TypeMask = 0x00000008, 
        SingleSel =
            0x00000010, 
        ShowSelAlways = 0x00000020, 
        SortAscending = 0x00000040, 
        SortDescending = 0x00000080, 
        ShareImageLists = 0x00000100, 
        NoLabelWrap = 0x00000200, 
        AutoArrange = 0x00000400, 
        EditLabels = 0x00000800, 
        OwnerData = 0x00001000, 
        NoScroll = 0x00002000, 
        TypeStyleMask = 0x00004000, 
        AlignTop = 0x00000001, 
        AlignLeft = 0x00008000, 
        AlignMask = 0x00010000, 
        OwnerDrawFixed = 0x00020000, 
        NoColumnHeader = 0x00040000, 
        NoSortHeader = 0x00080000, 
    };
    Q_DECLARE_FLAGS(Styles, Style);
 
    enum class ExtendedStyle : uint {
        GridLines = 0x00000001, // Displays gridlines around items and subitems.
        SubItemImages = 0x00000002, 
        CheckBoxes = 0x00000004, 
        TrackSelect = 0x00000008, 
        HeaderDragDrop = 0x00000010, 
        FullRowSelect = 0x00000020, // Selects the entire row of an item when it is selected.
        OneClickActivate = 0x00000040, 
        TwoClickActivate = 0x00000080, 
        FlatSB = 0x00000100, 
        Regional = 0x00000200, 
        InfoTip = 0x00000400, // Contextual tooltips from the listview, using infoTipRequested signal.
        UnderlineHot = 0x00000800, 
        UnderlineCold = 0x00001000, 
        MultiWorkAreas = 0x00002000, 
        LabelTip = 0x00004000, 
        BorderSelect = 0x00008000, 
        DoubleBuffer = 0x00010000, 
        HideLabels = 0x00020000, 
        SingleRow = 0x00040000, 
        SnapToGrid = 0x00080000, 
        SimpleSelect = 0x00100000, 
        JustifyColumns = 0x00200000, 
        TransparentBkgnd = 0x00400000, 
        TransparentShadowText = 0x00800000, 
        AutoAutoArrange = 0x01000000, 
        HeaderInAllViews = 0x02000000, 
        AutoCheckSelect = 0x08000000, 
        AutoSizeColumns = 0x10000000, 
        ColumnSnapPoints = 0x40000000, 
        ColumnOverflow = 0x80000000, 
    };
    Q_DECLARE_FLAGS(ExtendedStyles, ExtendedStyle);
 
    enum class StateMask : uint {
        Focused = 0x0001,
        Selected = 0x0002,
        Cut = 0x0004,
        DropHilited = 0x0008,
        Glow = 0x0010,
        Activating = 0x0020,
        OverlayMask = 0x0F00,
        StateImageMask = 0xF000,
    };
    Q_DECLARE_FLAGS(StateMasks, StateMask);
 
    enum class Mask : uint {
        Text = 0x00000001, 
        Image = 0x00000002, 
        Param = 0x00000004, 
        State = 0x00000008, 
        Indent = 0x00000010, 
        NoRecompute = 0x00000800, 
        GroupId = 0x00000100, 
        Columns = 0x00000200, 
        ColFmt = 0x00010000, 
    };
    Q_DECLARE_FLAGS(Masks, Mask);
 
    struct Item
    {
        Masks mask; 
        int iItem; 
        int iSubItem; 
        StateMask state; 
        StateMask stateMask; 
        KString pszText; 
        int cchTextMax; 
        int iImage; 
        void *lParam; 
        int iIndent; 
    };
 
    struct ChangedItem
    {
        int iItem;
        int iSubItem;
        void *lParam;
    };
 
    struct HitTestInfo
    {
        QPoint pt;
        int iItem;
        int iSubItem;
    };
 
    struct ColumnInfo
    {
        KString pszText;
    };
 
    enum class ImageList {
        Normal,
        Small,
        State,
    };
    Q_ENUM(ImageList);
 
    // MFC API from here on
 
    bool Create(KListModel::Styles style, const KRect &rect, QWidget *pParentWnd);
 
    Position GetFirstSelectedItemPosition() const;
    int GetNextSelectedItem(Position &pos) const;
    int GetSelectedCount() const;
 
    KString GetItemText(int nItem, int nSubItem) const;
    int InsertColumn(int nCol, const KString &lpszColumnHeading, Qt::AlignmentFlag nFormat = Qt::AlignLeft,
                     int nWidth = -1, int nSubItem = -1);
    bool SetColumnWidth(int nCol, int cx);
    bool DeleteAllItems();
    bool DeleteColumn(int nCol);
 
    int InsertItem(const Item *pItem);
    int InsertItem(int nItem, const KString &lpszItem);
 
    bool SetItem(const Item *pItem);
    bool SetItemText(int nItem, int nSubItem, const KString &lpszText);
 
    void GetClientRect(KRect *rect) const;
    bool GetWindowRect(KRect *r) const;
 
    Styles GetStyle() const;
    void SetStyle(Styles styles);
    ExtendedStyles GetExtendedStyle() const;
    void SetExtendedStyle(ExtendedStyles styles);
 
    int GetItemCount() const;
    bool SetItemData(int nItem, void *dwData);
    void *GetItemData(int nItem) const;
 
    bool GetCheckState(int nItem) const;
    bool GetCheck(int nItem) const;
    void SetCheckState(int nItem, bool checked);
 
    int GetScrollPos(Qt::Orientation orientation) const;
    int SetScrollPos(Qt::Orientation orientation, int pos, bool bRedraw = true);
 
    KHeaderCtrl *GetHeaderCtrl() const;
 
    int SubItemHitTest(HitTestInfo *pInfo);
 
    bool GetColumn(int nCol, ColumnInfo *pColumn) const;
 
    KImageList *SetImageList(KImageList *pImageList, KListModel::ImageList imageListType);
 
    bool SortItems(KSortFilterProxyModel::SortFunction lessThan);
#ifdef KDWINUTILS_WITHMFC
    bool SortItems(PFNLVCOMPARE fn, std::uintptr_t param);
#endif // KDWINUTILS_WITHMFC
 
    bool EnsureVisible(int nItem, bool bPartialOK);
 
    bool SetItemState(int nItem, StateMasks nState, StateMasks nMask);
 
signals:
    void infoTipRequested(QHelpEvent *, const QModelIndex &);
    void itemChanged(const ChangedItem &);
    void contextMenuRequested(QObject *obj, const QPoint &);
    void headerClicked(int section);
 
public slots:
    void setFilterFixedString(const KString &pattern);
    void setFilterRegularExpression(const KString &pattern);
    void setFilterRegularExpression(const QRegularExpression &regularExpression);
    void setFilterWildcard(const KString &pattern);
 
private:
    friend class StyledItemDelegate;
 
    struct CellData
    {
        KString text;
        int imageIndex;
        void *lParam;
        bool checkState;
    };
    using ListItem = std::vector<CellData>;
 
    struct HeaderData
    {
        CellData cellData;
        Qt::AlignmentFlag alignment;
    };
    using HeaderItem = std::vector<HeaderData>;
 
    QTreeView *m_widget = nullptr;
    std::unique_ptr<KItemViewToolTipHandler> m_toolTipHandler;
    HeaderItem m_headerItem;
    KHeaderCtrl *m_headerCtrl;
    QList<ListItem> m_data;
    Styles m_styles {};
    ExtendedStyles m_extendedStyles {};
 
    KImageList *m_imageListNormal = nullptr;
    KImageList *m_imageListSmall = nullptr;
    KImageList *m_imageListState = nullptr;
 
    StyledItemDelegate *m_delegate;
 
    KSortFilterProxyModel *m_sortFilterProxy = nullptr;
 
    CustomPaintFunction m_customPaintFunction;
 
    friend class KHeaderCtrl;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS(KListModel::Masks)
Q_DECLARE_OPERATORS_FOR_FLAGS(KListModel::StateMasks)
Q_DECLARE_OPERATORS_FOR_FLAGS(KListModel::Styles)
Q_DECLARE_OPERATORS_FOR_FLAGS(KListModel::ExtendedStyles)
 
template <typename Class>
inline void KListModel::setCustomPaintFunction(Class *object,
                                               void (Class::*method)(QPainter *painter,
                                                                     const QStyleOptionViewItem &styleOption,
                                                                     const QModelIndex &index))
{
    setCustomPaintFunction(
        object, [object, method](QPainter *painter, const QStyleOptionViewItem &styleOption, const QModelIndex &index) {
            return (object->*method)(painter, styleOption, index);
        });
}
 
KDWINUTILS_END_NAMESPACE