File indexing completed on 2024-04-28 05:45:07

 /*
  * SPDX-FileCopyrightText: 2011 Peter Penz <peter.penz19@gmail.com>
  *
  * Based on the Itemviews NG project from Trolltech Labs
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "kstandarditemlistgroupheader.h"
 
 #include "kitemlistview.h"
 
 #include <QGraphicsSceneResizeEvent>
 #include <QPainter>
 #include <QStyleOptionGraphicsItem>
 
 KItemListGroupHeader::KItemListGroupHeader(QGraphicsWidget *parent)
     : QGraphicsWidget(parent)
     , m_dirtyCache(true)
     , m_role()
     , m_data()
     , m_styleOption()
     , m_scrollOrientation(Qt::Vertical)
     , m_itemIndex(-1)
     , m_separatorColor()
     , m_roleColor()
     , m_roleBounds()
 {
 }
 
 KItemListGroupHeader::~KItemListGroupHeader()
 {
 }
 
 void KItemListGroupHeader::setRole(const QByteArray &role)
 {
     if (m_role != role) {
         const QByteArray previous = m_role;
         m_role = role;
         update();
         roleChanged(role, previous);
     }
 }
 
 QByteArray KItemListGroupHeader::role() const
 {
     return m_role;
 }
 
 void KItemListGroupHeader::setData(const QVariant &data)
 {
     if (m_data != data) {
         const QVariant previous = m_data;
         m_data = data;
         update();
         dataChanged(data, previous);
     }
 }
 
 QVariant KItemListGroupHeader::data() const
 {
     return m_data;
 }
 
 void KItemListGroupHeader::setStyleOption(const KItemListStyleOption &option)
 {
     if (m_styleOption == option) {
         return;
     }
 
     const KItemListStyleOption previous = m_styleOption;
     m_styleOption = option;
     m_dirtyCache = true;
     styleOptionChanged(option, previous);
 }
 
 const KItemListStyleOption &KItemListGroupHeader::styleOption() const
 {
     return m_styleOption;
 }
 
 void KItemListGroupHeader::setScrollOrientation(Qt::Orientation orientation)
 {
     if (m_scrollOrientation != orientation) {
         const Qt::Orientation previous = m_scrollOrientation;
         m_scrollOrientation = orientation;
         if (orientation == Qt::Vertical) {
             m_dirtyCache = true;
         }
         scrollOrientationChanged(orientation, previous);
     }
 }
 
 void KItemListGroupHeader::setItemIndex(int index)
 {
     if (m_itemIndex != index) {
         const int previous = m_itemIndex;
         m_itemIndex = index;
         m_dirtyCache = true;
         itemIndexChanged(m_itemIndex, previous);
     }
 }
 
 int KItemListGroupHeader::itemIndex() const
 {
     return m_itemIndex;
 }
 
 Qt::Orientation KItemListGroupHeader::scrollOrientation() const
 {
     return m_scrollOrientation;
 }
 
 void KItemListGroupHeader::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
     Q_UNUSED(painter)
     Q_UNUSED(option)
     Q_UNUSED(widget)
 
     if (m_dirtyCache) {
         updateCache();
     }
 
     paintSeparator(painter, m_separatorColor);
     paintRole(painter, m_roleBounds, m_roleColor);
 }
 
 void KItemListGroupHeader::roleChanged(const QByteArray &current, const QByteArray &previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
 }
 
 void KItemListGroupHeader::dataChanged(const QVariant &current, const QVariant &previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
 }
 
 void KItemListGroupHeader::styleOptionChanged(const KItemListStyleOption &current, const KItemListStyleOption &previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
 }
 
 void KItemListGroupHeader::scrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
 }
 
 void KItemListGroupHeader::itemIndexChanged(int current, int previous)
 {
     Q_UNUSED(current)
     Q_UNUSED(previous)
 }
 
 void KItemListGroupHeader::resizeEvent(QGraphicsSceneResizeEvent *event)
 {
     QGraphicsWidget::resizeEvent(event);
     if (event->oldSize().height() != event->newSize().height()) {
         m_dirtyCache = true;
     }
     updateSize();
 }
 
 void KItemListGroupHeader::updateCache()
 {
     Q_ASSERT(m_dirtyCache);
 
     // Calculate the role- and line-color. No alphablending is used for
     // performance reasons.
     const QColor c1 = textColor();
     const QColor c2 = baseColor();
     m_separatorColor = mixedColor(c1, c2, 10);
     m_roleColor = mixedColor(c1, c2, 60);
 
     updateSize();
 
     m_dirtyCache = false;
 }
 
 void KItemListGroupHeader::updateSize()
 {
     const int padding = qMax(1, m_styleOption.padding);
     const int horizontalMargin = qMax(2, m_styleOption.horizontalMargin);
 
     const QFontMetrics fontMetrics(m_styleOption.font);
     const qreal roleHeight = fontMetrics.height();
 
     const int y = (m_scrollOrientation == Qt::Vertical) ? padding : horizontalMargin;
 
     m_roleBounds = QRectF(horizontalMargin + padding, y, size().width() - 2 * padding - horizontalMargin, roleHeight);
 
     update();
 }
 
 QColor KItemListGroupHeader::mixedColor(const QColor &c1, const QColor &c2, int c1Percent)
 {
     Q_ASSERT(c1Percent >= 0 && c1Percent <= 100);
 
     const int c2Percent = 100 - c1Percent;
     return QColor((c1.red() * c1Percent + c2.red() * c2Percent) / 100,
                   (c1.green() * c1Percent + c2.green() * c2Percent) / 100,
                   (c1.blue() * c1Percent + c2.blue() * c2Percent) / 100);
 }
 
 QPalette::ColorRole KItemListGroupHeader::normalTextColorRole() const
 {
     return QPalette::Text;
 }
 
 QPalette::ColorRole KItemListGroupHeader::normalBaseColorRole() const
 {
     return QPalette::Window;
 }
 
 QColor KItemListGroupHeader::textColor() const
 {
     const QPalette::ColorGroup group = isActiveWindow() ? QPalette::Active : QPalette::Inactive;
     return styleOption().palette.color(group, normalTextColorRole());
 }
 
 QColor KItemListGroupHeader::baseColor() const
 {
     const QPalette::ColorGroup group = isActiveWindow() ? QPalette::Active : QPalette::Inactive;
     return styleOption().palette.color(group, normalBaseColorRole());
 }
 
 #include "moc_kitemlistgroupheader.cpp"