Port from KIconLoader::drawOverlays to KIconUtils::addOverlays

[dolphin.git] / src / kitemviews / private / kitemlistheaderwidget.cpp

diff --git a/src/kitemviews/private/kitemlistheaderwidget.cpp b/src/kitemviews/private/kitemlistheaderwidget.cpp
index 5fb929e5209b50bf48b696e68df93b08dd46978a..02a4f939d13b2e26f0b3e43ed301799a6a57e739 100644 (file)
--- a/src/kitemviews/private/kitemlistheaderwidget.cpp
+++ b/src/kitemviews/private/kitemlistheaderwidget.cpp
@@ -12,57 +12,54 @@
 #include <QPainter>
 #include <QStyleOptionHeader>
 
 #include <QPainter>
 #include <QStyleOptionHeader>
 

-
-KItemListHeaderWidget::KItemListHeaderWidget(QGraphicsWidget* parent) :
-    QGraphicsWidget(parent),
-    m_automaticColumnResizing(true),
-    m_model(nullptr),
-    m_offset(0),
-    m_leadingPadding(0),
-    m_columns(),
-    m_columnWidths(),
-    m_preferredColumnWidths(),
-    m_hoveredRoleIndex(-1),
-    m_pressedRoleIndex(-1),
-    m_roleOperation(NoRoleOperation),
-    m_pressedMousePos(),
-    m_movingRole()
+KItemListHeaderWidget::KItemListHeaderWidget(QGraphicsWidget *parent)
+    : QGraphicsWidget(parent)
+    , m_automaticColumnResizing(true)
+    , m_model(nullptr)
+    , m_offset(0)
+    , m_sidePadding(0)
+    , m_columns()
+    , m_columnWidths()
+    , m_preferredColumnWidths()
+    , m_hoveredIndex(-1)
+    , m_pressedRoleIndex(-1)
+    , m_roleOperation(NoRoleOperation)
+    , m_pressedMousePos()
+    , m_movingRole()

 {
     m_movingRole.x = 0;
     m_movingRole.xDec = 0;
     m_movingRole.index = -1;
 
     setAcceptHoverEvents(true);
 {
     m_movingRole.x = 0;
     m_movingRole.xDec = 0;
     m_movingRole.index = -1;
 
     setAcceptHoverEvents(true);

+    // TODO update when font changes at runtime
+    setFont(QApplication::font("QHeaderView"));

 }
 
 KItemListHeaderWidget::~KItemListHeaderWidget()
 {
 }
 
 }
 
 KItemListHeaderWidget::~KItemListHeaderWidget()
 {
 }
 

-void KItemListHeaderWidget::setModel(KItemModelBase* model)
+void KItemListHeaderWidget::setModel(KItemModelBase *model)

 {
     if (m_model == model) {
         return;
     }
 
     if (m_model) {
 {
     if (m_model == model) {
         return;
     }
 
     if (m_model) {

-        disconnect(m_model, &KItemModelBase::sortRoleChanged,
-                   this, &KItemListHeaderWidget::slotSortRoleChanged);
-        disconnect(m_model, &KItemModelBase::sortOrderChanged,
-                   this, &KItemListHeaderWidget::slotSortOrderChanged);
+        disconnect(m_model, &KItemModelBase::sortRoleChanged, this, &KItemListHeaderWidget::slotSortRoleChanged);
+        disconnect(m_model, &KItemModelBase::sortOrderChanged, this, &KItemListHeaderWidget::slotSortOrderChanged);

     }
 
     m_model = model;
 
     if (m_model) {
     }
 
     m_model = model;
 
     if (m_model) {

-        connect(m_model, &KItemModelBase::sortRoleChanged,
-                this, &KItemListHeaderWidget::slotSortRoleChanged);
-        connect(m_model, &KItemModelBase::sortOrderChanged,
-                this, &KItemListHeaderWidget::slotSortOrderChanged);
+        connect(m_model, &KItemModelBase::sortRoleChanged, this, &KItemListHeaderWidget::slotSortRoleChanged);
+        connect(m_model, &KItemModelBase::sortOrderChanged, this, &KItemListHeaderWidget::slotSortOrderChanged);

     }
 }
 
     }
 }
 

-KItemModelBase* KItemListHeaderWidget::model() const
+KItemModelBase *KItemListHeaderWidget::model() const

 {
     return m_model;
 }
 {
     return m_model;
 }


@@ -77,9 +74,9 @@ bool KItemListHeaderWidget::automaticColumnResizing() const
     return m_automaticColumnResizing;
 }
 
     return m_automaticColumnResizing;
 }
 

-void KItemListHeaderWidget::setColumns(const QList<QByteArray>& roles)
+void KItemListHeaderWidget::setColumns(const QList<QByteArray> &roles)

 {
 {

-    for (const QByteArray& role : roles) {
+    for (const QByteArray &role : roles) {

         if (!m_columnWidths.contains(role)) {
             m_preferredColumnWidths.remove(role);
         }
         if (!m_columnWidths.contains(role)) {
             m_preferredColumnWidths.remove(role);
         }


@@ -94,7 +91,7 @@ QList<QByteArray> KItemListHeaderWidget::columns() const
     return m_columns;
 }
 
     return m_columns;
 }
 

-void KItemListHeaderWidget::setColumnWidth(const QByteArray& role, qreal width)
+void KItemListHeaderWidget::setColumnWidth(const QByteArray &role, qreal width)

 {
     const qreal minWidth = minimumColumnWidth();
     if (width < minWidth) {
 {
     const qreal minWidth = minimumColumnWidth();
     if (width < minWidth) {


@@ -107,17 +104,17 @@ void KItemListHeaderWidget::setColumnWidth(const QByteArray& role, qreal width)
     }
 }
 
     }
 }
 

-qreal KItemListHeaderWidget::columnWidth(const QByteArray& role) const
+qreal KItemListHeaderWidget::columnWidth(const QByteArray &role) const

 {
     return m_columnWidths.value(role);
 }
 
 {
     return m_columnWidths.value(role);
 }
 

-void KItemListHeaderWidget::setPreferredColumnWidth(const QByteArray& role, qreal width)
+void KItemListHeaderWidget::setPreferredColumnWidth(const QByteArray &role, qreal width)

 {
     m_preferredColumnWidths.insert(role, width);
 }
 
 {
     m_preferredColumnWidths.insert(role, width);
 }
 

-qreal KItemListHeaderWidget::preferredColumnWidth(const QByteArray& role) const
+qreal KItemListHeaderWidget::preferredColumnWidth(const QByteArray &role) const

 {
     return m_preferredColumnWidths.value(role);
 }
 {
     return m_preferredColumnWidths.value(role);
 }


@@ -135,18 +132,18 @@ qreal KItemListHeaderWidget::offset() const
     return m_offset;
 }
 
     return m_offset;
 }
 

-void KItemListHeaderWidget::setLeadingPadding(qreal width)
+void KItemListHeaderWidget::setSidePadding(qreal width)

 {
 {

-    if (m_leadingPadding != width) {
-        m_leadingPadding = width;
-        leadingPaddingChanged(width);
+    if (m_sidePadding != width) {
+        m_sidePadding = width;
+        Q_EMIT sidePaddingChanged(width);

         update();
     }
 }
 
         update();
     }
 }
 

-qreal KItemListHeaderWidget::leadingPadding() const
+qreal KItemListHeaderWidget::sidePadding() const

 {
 {

-    return m_leadingPadding;
+    return m_sidePadding;

 }
 
 qreal KItemListHeaderWidget::minimumColumnWidth() const
 }
 
 qreal KItemListHeaderWidget::minimumColumnWidth() const


@@ -155,7 +152,7 @@ qreal KItemListHeaderWidget::minimumColumnWidth() const
     return fontMetrics.height() * 4;
 }
 
     return fontMetrics.height() * 4;
 }
 

-void KItemListHeaderWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
+void KItemListHeaderWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

 {
     Q_UNUSED(option)
     Q_UNUSED(widget)
 {
     Q_UNUSED(option)
     Q_UNUSED(widget)


@@ -168,9 +165,9 @@ void KItemListHeaderWidget::paint(QPainter* painter, const QStyleOptionGraphicsI
     painter->setFont(font());
     painter->setPen(palette().text().color());
 
     painter->setFont(font());
     painter->setPen(palette().text().color());
 

-    qreal x = -m_offset + m_leadingPadding;
+    qreal x = -m_offset + m_sidePadding;

     int orderIndex = 0;
     int orderIndex = 0;

-    for (const QByteArray& role : qAsConst(m_columns)) {
+    for (const QByteArray &role : std::as_const(m_columns)) {

         const qreal roleWidth = m_columnWidths.value(role);
         const QRectF rect(x, 0, roleWidth, size().height());
         paintRole(painter, role, rect, orderIndex, widget);
         const qreal roleWidth = m_columnWidths.value(role);
         const QRectF rect(x, 0, roleWidth, size().height());
         paintRole(painter, role, rect, orderIndex, widget);


@@ -184,16 +181,15 @@ void KItemListHeaderWidget::paint(QPainter* painter, const QStyleOptionGraphicsI
     }
 }
 
     }
 }
 

-void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)

 {
     if (event->button() & Qt::LeftButton) {
         m_pressedMousePos = event->pos();
         if (isAbovePaddingGrip(m_pressedMousePos, PaddingGrip::Leading)) {
 {
     if (event->button() & Qt::LeftButton) {
         m_pressedMousePos = event->pos();
         if (isAbovePaddingGrip(m_pressedMousePos, PaddingGrip::Leading)) {

-            m_roleOperation = ResizeLeadingColumnOperation;
+            m_roleOperation = ResizePaddingColumnOperation;

         } else {
             updatePressedRoleIndex(event->pos());
         } else {
             updatePressedRoleIndex(event->pos());

-            m_roleOperation = isAboveRoleGrip(m_pressedMousePos, m_pressedRoleIndex) ?
-                              ResizeRoleOperation : NoRoleOperation;
+            m_roleOperation = isAboveRoleGrip(m_pressedMousePos, m_pressedRoleIndex) ? ResizeRoleOperation : NoRoleOperation;

         }
         event->accept();
     } else {
         }
         event->accept();
     } else {


@@ -201,7 +197,7 @@ void KItemListHeaderWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)
     }
 }
 
     }
 }
 

-void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

 {
     QGraphicsWidget::mouseReleaseEvent(event);
 
 {
     QGraphicsWidget::mouseReleaseEvent(event);
 


@@ -217,8 +213,7 @@ void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
         if (m_pressedRoleIndex == sortRoleIndex) {
             // Toggle the sort order
             const Qt::SortOrder previous = m_model->sortOrder();
         if (m_pressedRoleIndex == sortRoleIndex) {
             // Toggle the sort order
             const Qt::SortOrder previous = m_model->sortOrder();

-            const Qt::SortOrder current = (m_model->sortOrder() == Qt::AscendingOrder) ?
-                                          Qt::DescendingOrder : Qt::AscendingOrder;
+            const Qt::SortOrder current = (m_model->sortOrder() == Qt::AscendingOrder) ? Qt::DescendingOrder : Qt::AscendingOrder;

             m_model->setSortOrder(current);
             Q_EMIT sortOrderChanged(current, previous);
         } else {
             m_model->setSortOrder(current);
             Q_EMIT sortOrderChanged(current, previous);
         } else {


@@ -262,7 +257,7 @@ void KItemListHeaderWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
     QApplication::restoreOverrideCursor();
 }
 
     QApplication::restoreOverrideCursor();
 }
 

-void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

 {
     QGraphicsWidget::mouseMoveEvent(event);
 
 {
     QGraphicsWidget::mouseMoveEvent(event);
 


@@ -282,7 +277,7 @@ void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
             } else {
                 m_movingRole.pixmap = createRolePixmap(roleIndex);
 
             } else {
                 m_movingRole.pixmap = createRolePixmap(roleIndex);
 

-                qreal roleX = -m_offset + m_leadingPadding;
+                qreal roleX = -m_offset + m_sidePadding;

                 for (int i = 0; i < roleIndex; ++i) {
                     const QByteArray role = m_columns[i];
                     roleX += m_columnWidths.value(role);
                 for (int i = 0; i < roleIndex; ++i) {
                     const QByteArray role = m_columns[i];
                     roleX += m_columnWidths.value(role);


@@ -310,16 +305,16 @@ void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
         break;
     }
 
         break;
     }
 

-    case ResizeLeadingColumnOperation: {
-        qreal currentWidth = m_leadingPadding;
+    case ResizePaddingColumnOperation: {
+        qreal currentWidth = m_sidePadding;

         currentWidth += event->pos().x() - event->lastPos().x();
         currentWidth = qMax(0.0, currentWidth);
 
         currentWidth += event->pos().x() - event->lastPos().x();
         currentWidth = qMax(0.0, currentWidth);
 

-        m_leadingPadding = currentWidth;
+        m_sidePadding = currentWidth;

 
         update();
 
 
         update();
 

-        Q_EMIT leadingPaddingChanged(currentWidth);
+        Q_EMIT sidePaddingChanged(currentWidth);

 
         break;
     }
 
         break;
     }


@@ -350,7 +345,7 @@ void KItemListHeaderWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
     }
 }
 
     }
 }
 

-void KItemListHeaderWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+void KItemListHeaderWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)

 {
     QGraphicsItem::mouseDoubleClickEvent(event);
 
 {
     QGraphicsItem::mouseDoubleClickEvent(event);
 


@@ -367,37 +362,37 @@ void KItemListHeaderWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* even
     }
 }
 
     }
 }
 

-void KItemListHeaderWidget::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
+void KItemListHeaderWidget::hoverEnterEvent(QGraphicsSceneHoverEvent *event)

 {
     QGraphicsWidget::hoverEnterEvent(event);
 {
     QGraphicsWidget::hoverEnterEvent(event);

-    updateHoveredRoleIndex(event->pos());
+    updateHoveredIndex(event->pos());

 }
 
 }
 

-void KItemListHeaderWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent* event)
+void KItemListHeaderWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)

 {
     QGraphicsWidget::hoverLeaveEvent(event);
 {
     QGraphicsWidget::hoverLeaveEvent(event);

-    if (m_hoveredRoleIndex != -1) {
-        m_hoveredRoleIndex = -1;
+    if (m_hoveredIndex != -1) {
+        Q_EMIT columnUnHovered(m_hoveredIndex);
+        m_hoveredIndex = -1;

         update();
     }
 }
 
         update();
     }
 }
 

-void KItemListHeaderWidget::hoverMoveEvent(QGraphicsSceneHoverEvent* event)
+void KItemListHeaderWidget::hoverMoveEvent(QGraphicsSceneHoverEvent *event)

 {
     QGraphicsWidget::hoverMoveEvent(event);
 
 {
     QGraphicsWidget::hoverMoveEvent(event);
 

-    const QPointF& pos = event->pos();
-    updateHoveredRoleIndex(pos);
-    if ((m_hoveredRoleIndex >= 0 && isAboveRoleGrip(pos, m_hoveredRoleIndex)) ||
-            isAbovePaddingGrip(pos, PaddingGrip::Leading) ||
-        isAbovePaddingGrip(pos, PaddingGrip::Trailing)) {
+    const QPointF &pos = event->pos();
+    updateHoveredIndex(pos);
+    if ((m_hoveredIndex >= 0 && isAboveRoleGrip(pos, m_hoveredIndex)) || isAbovePaddingGrip(pos, PaddingGrip::Leading)
+        || isAbovePaddingGrip(pos, PaddingGrip::Trailing)) {

         setCursor(Qt::SplitHCursor);
     } else {
         unsetCursor();
     }
 }
 
         setCursor(Qt::SplitHCursor);
     } else {
         unsetCursor();
     }
 }
 

-void KItemListHeaderWidget::slotSortRoleChanged(const QByteArray& current, const QByteArray& previous)
+void KItemListHeaderWidget::slotSortRoleChanged(const QByteArray &current, const QByteArray &previous)

 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)


@@ -411,20 +406,15 @@ void KItemListHeaderWidget::slotSortOrderChanged(Qt::SortOrder current, Qt::Sort
     update();
 }
 
     update();
 }
 

-void KItemListHeaderWidget::paintRole(QPainter* painter,
-                                      const QByteArray& role,
-                                      const QRectF& rect,
-                                      int orderIndex,
-                                      QWidget* widget) const
+void KItemListHeaderWidget::paintRole(QPainter *painter, const QByteArray &role, const QRectF &rect, int orderIndex, QWidget *widget) const

 {
 {

+    const auto direction = widget ? widget->layoutDirection() : qApp->layoutDirection();
+

     // The following code is based on the code from QHeaderView::paintSection().
     // SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
     QStyleOptionHeader option;
     // The following code is based on the code from QHeaderView::paintSection().
     // SPDX-FileCopyrightText: 2011 Nokia Corporation and/or its subsidiary(-ies).
     QStyleOptionHeader option;

-    option.direction = widget->layoutDirection();
-    option.textAlignment =
-        widget->layoutDirection() == Qt::LeftToRight
-            ? Qt::AlignLeft
-            : Qt::AlignRight;
+    option.direction = direction;
+    option.textAlignment = direction == Qt::LeftToRight ? Qt::AlignLeft : Qt::AlignRight;

 
     option.section = orderIndex;
     option.state = QStyle::State_None | QStyle::State_Raised | QStyle::State_Horizontal;
 
     option.section = orderIndex;
     option.state = QStyle::State_None | QStyle::State_Raised | QStyle::State_Horizontal;


@@ -434,15 +424,14 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
     if (window() && window()->isActiveWindow()) {
         option.state |= QStyle::State_Active;
     }
     if (window() && window()->isActiveWindow()) {
         option.state |= QStyle::State_Active;
     }

-    if (m_hoveredRoleIndex == orderIndex) {
+    if (m_hoveredIndex == orderIndex) {

         option.state |= QStyle::State_MouseOver;
     }
     if (m_pressedRoleIndex == orderIndex) {
         option.state |= QStyle::State_Sunken;
     }
     if (m_model->sortRole() == role) {
         option.state |= QStyle::State_MouseOver;
     }
     if (m_pressedRoleIndex == orderIndex) {
         option.state |= QStyle::State_Sunken;
     }
     if (m_model->sortRole() == role) {

-        option.sortIndicator = (m_model->sortOrder() == Qt::AscendingOrder) ?
-                                QStyleOptionHeader::SortDown : QStyleOptionHeader::SortUp;
+        option.sortIndicator = (m_model->sortOrder() == Qt::AscendingOrder) ? QStyleOptionHeader::SortDown : QStyleOptionHeader::SortUp;

     }
     option.rect = rect.toRect();
     option.orientation = Qt::Horizontal;
     }
     option.rect = rect.toRect();
     option.orientation = Qt::Horizontal;


@@ -450,7 +439,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
     option.text = m_model->roleDescription(role);
 
     // First we paint any potential empty (padding) space on left and/or right of this role's column.
     option.text = m_model->roleDescription(role);
 
     // First we paint any potential empty (padding) space on left and/or right of this role's column.

-    const auto paintPadding = [&](int section, const QRectF &rect, const QStyleOptionHeader::SectionPosition &pos){
+    const auto paintPadding = [&](int section, const QRectF &rect, const QStyleOptionHeader::SectionPosition &pos) {

         QStyleOptionHeader padding;
         padding.state = QStyle::State_None | QStyle::State_Raised | QStyle::State_Horizontal;
         padding.section = section;
         QStyleOptionHeader padding;
         padding.state = QStyle::State_None | QStyle::State_Raised | QStyle::State_Horizontal;
         padding.section = section;


@@ -469,7 +458,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
         // Paint the header for the first column; check if there is some empty space to the left which needs to be filled.
         if (rect.left() > 0) {
             option.position = QStyleOptionHeader::Middle;
         // Paint the header for the first column; check if there is some empty space to the left which needs to be filled.
         if (rect.left() > 0) {
             option.position = QStyleOptionHeader::Middle;

-            paintPadding(0,QRectF(0.0, 0.0, rect.left(), rect.height()), QStyleOptionHeader::Beginning);
+            paintPadding(0, QRectF(0.0, 0.0, rect.left(), rect.height()), QStyleOptionHeader::Beginning);

         } else {
             option.position = QStyleOptionHeader::Beginning;
         }
         } else {
             option.position = QStyleOptionHeader::Beginning;
         }


@@ -488,7 +477,7 @@ void KItemListHeaderWidget::paintRole(QPainter* painter,
     style()->drawControl(QStyle::CE_Header, &option, painter, widget);
 }
 
     style()->drawControl(QStyle::CE_Header, &option, painter, widget);
 }
 

-void KItemListHeaderWidget::updatePressedRoleIndex(const QPointF& pos)
+void KItemListHeaderWidget::updatePressedRoleIndex(const QPointF &pos)

 {
     const int pressedIndex = roleIndexAt(pos);
     if (m_pressedRoleIndex != pressedIndex) {
 {
     const int pressedIndex = roleIndexAt(pos);
     if (m_pressedRoleIndex != pressedIndex) {


@@ -497,21 +486,28 @@ void KItemListHeaderWidget::updatePressedRoleIndex(const QPointF& pos)
     }
 }
 
     }
 }
 

-void KItemListHeaderWidget::updateHoveredRoleIndex(const QPointF& pos)
+void KItemListHeaderWidget::updateHoveredIndex(const QPointF &pos)

 {
     const int hoverIndex = roleIndexAt(pos);
 {
     const int hoverIndex = roleIndexAt(pos);

-    if (m_hoveredRoleIndex != hoverIndex) {
-        m_hoveredRoleIndex = hoverIndex;
+
+    if (m_hoveredIndex != hoverIndex) {
+        if (m_hoveredIndex != -1) {
+            Q_EMIT columnUnHovered(m_hoveredIndex);
+        }
+        m_hoveredIndex = hoverIndex;
+        if (m_hoveredIndex != -1) {
+            Q_EMIT columnHovered(m_hoveredIndex);
+        }

         update();
     }
 }
 
         update();
     }
 }
 

-int KItemListHeaderWidget::roleIndexAt(const QPointF& pos) const
+int KItemListHeaderWidget::roleIndexAt(const QPointF &pos) const

 {
     int index = -1;
 
 {
     int index = -1;
 

-    qreal x = -m_offset + m_leadingPadding;
-    for (const QByteArray& role : qAsConst(m_columns)) {
+    qreal x = -m_offset + m_sidePadding;
+    for (const QByteArray &role : std::as_const(m_columns)) {

         ++index;
         x += m_columnWidths.value(role);
         if (pos.x() <= x) {
         ++index;
         x += m_columnWidths.value(role);
         if (pos.x() <= x) {


@@ -522,9 +518,9 @@ int KItemListHeaderWidget::roleIndexAt(const QPointF& pos) const
     return index;
 }
 
     return index;
 }
 

-bool KItemListHeaderWidget::isAboveRoleGrip(const QPointF& pos, int roleIndex) const
+bool KItemListHeaderWidget::isAboveRoleGrip(const QPointF &pos, int roleIndex) const

 {
 {

-    qreal x = -m_offset + m_leadingPadding;
+    qreal x = -m_offset + m_sidePadding;

     for (int i = 0; i <= roleIndex; ++i) {
         const QByteArray role = m_columns[i];
         x += m_columnWidths.value(role);
     for (int i = 0; i <= roleIndex; ++i) {
         const QByteArray role = m_columns[i];
         x += m_columnWidths.value(role);


@@ -534,18 +530,17 @@ bool KItemListHeaderWidget::isAboveRoleGrip(const QPointF& pos, int roleIndex) c
     return pos.x() >= (x - grip) && pos.x() <= x;
 }
 
     return pos.x() >= (x - grip) && pos.x() <= x;
 }
 

-bool KItemListHeaderWidget::isAbovePaddingGrip(const QPointF& pos, PaddingGrip paddingGrip) const
+bool KItemListHeaderWidget::isAbovePaddingGrip(const QPointF &pos, PaddingGrip paddingGrip) const

 {
 {

-    const qreal lx = -m_offset + m_leadingPadding;
+    const qreal lx = -m_offset + m_sidePadding;

     const int grip = style()->pixelMetric(QStyle::PM_HeaderGripMargin);
 
     switch (paddingGrip) {
     case Leading:
         return pos.x() >= (lx - grip) && pos.x() <= lx;
     const int grip = style()->pixelMetric(QStyle::PM_HeaderGripMargin);
 
     switch (paddingGrip) {
     case Leading:
         return pos.x() >= (lx - grip) && pos.x() <= lx;

-    case Trailing:
-    {
+    case Trailing: {

         qreal rx = lx;
         qreal rx = lx;

-        for (const QByteArray& role : qAsConst(m_columns)) {
+        for (const QByteArray &role : std::as_const(m_columns)) {

             rx += m_columnWidths.value(role);
         }
         return pos.x() >= (rx - grip) && pos.x() <= rx;
             rx += m_columnWidths.value(role);
         }
         return pos.x() >= (rx - grip) && pos.x() <= rx;


@@ -586,18 +581,14 @@ int KItemListHeaderWidget::targetOfMovingRole() const
     const int movingRight = movingLeft + movingWidth - 1;
 
     int targetIndex = 0;
     const int movingRight = movingLeft + movingWidth - 1;
 
     int targetIndex = 0;

-    qreal targetLeft = -m_offset + m_leadingPadding;
+    qreal targetLeft = -m_offset + m_sidePadding;

     while (targetIndex < m_columns.count()) {
         const QByteArray role = m_columns[targetIndex];
         const qreal targetWidth = m_columnWidths.value(role);
         const qreal targetRight = targetLeft + targetWidth - 1;
 
     while (targetIndex < m_columns.count()) {
         const QByteArray role = m_columns[targetIndex];
         const qreal targetWidth = m_columnWidths.value(role);
         const qreal targetRight = targetLeft + targetWidth - 1;
 

-        const bool isInTarget = (targetWidth >= movingWidth &&
-                                 movingLeft  >= targetLeft  &&
-                                 movingRight <= targetRight) ||
-                                (targetWidth <  movingWidth &&
-                                 movingLeft  <= targetLeft  &&
-                                 movingRight >= targetRight);
+        const bool isInTarget = (targetWidth >= movingWidth && movingLeft >= targetLeft && movingRight <= targetRight)
+            || (targetWidth < movingWidth && movingLeft <= targetLeft && movingRight >= targetRight);

 
         if (isInTarget) {
             return targetIndex;
 
         if (isInTarget) {
             return targetIndex;


@@ -610,10 +601,10 @@ int KItemListHeaderWidget::targetOfMovingRole() const
     return m_movingRole.index;
 }
 
     return m_movingRole.index;
 }
 

-qreal KItemListHeaderWidget::roleXPosition(const QByteArray& role) const
+qreal KItemListHeaderWidget::roleXPosition(const QByteArray &role) const

 {
 {

-    qreal x = -m_offset + m_leadingPadding;
-    for (const QByteArray& visibleRole : qAsConst(m_columns)) {
+    qreal x = -m_offset + m_sidePadding;
+    for (const QByteArray &visibleRole : std::as_const(m_columns)) {

         if (visibleRole == role) {
             return x;
         }
         if (visibleRole == role) {
             return x;
         }


@@ -624,3 +615,4 @@ qreal KItemListHeaderWidget::roleXPosition(const QByteArray& role) const
     return -1;
 }
 
     return -1;
 }
 

+#include "moc_kitemlistheaderwidget.cpp"