File indexing completed on 2024-04-28 03:59:09

 /*
     SPDX-FileCopyrightText: 2001, 2002, 2003 Joseph Wenninger <jowenn@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kmultitabbar.h"
 #include "kmultitabbar_p.h"
 #include "moc_kmultitabbar.cpp"
 #include "moc_kmultitabbar_p.cpp"
 
 #include <QMouseEvent>
 #include <QPainter>
 #include <QStyle>
 #include <QStyleOptionButton>
 
 #include <math.h>
 
 /*
  A bit of an overview about what's going on here:
  There are two sorts of things that can be in the tab bar: tabs and regular
  buttons. The former are managed by KMultiTabBarInternal, the later
  by the KMultiTabBar itself.
 */
 
 class KMultiTabBarTabPrivate
 {
 };
 class KMultiTabBarButtonPrivate
 {
 };
 
 class KMultiTabBarPrivate
 {
 public:
     class KMultiTabBarInternal *m_internal;
     QBoxLayout *m_l;
     QFrame *m_btnTabSep;
     QList<KMultiTabBarButton *> m_buttons;
     KMultiTabBar::KMultiTabBarPosition m_position;
 };
 
 KMultiTabBarInternal::KMultiTabBarInternal(QWidget *parent, KMultiTabBar::KMultiTabBarPosition pos)
     : QFrame(parent)
 {
     m_position = pos;
     if (pos == KMultiTabBar::Left || pos == KMultiTabBar::Right) {
         mainLayout = new QVBoxLayout(this);
     } else {
         mainLayout = new QHBoxLayout(this);
     }
     mainLayout->setContentsMargins(0, 0, 0, 0);
     mainLayout->setSpacing(0);
     mainLayout->addStretch();
     setFrameStyle(NoFrame);
     setBackgroundRole(QPalette::Window);
 }
 
 KMultiTabBarInternal::~KMultiTabBarInternal()
 {
     qDeleteAll(m_tabs);
     m_tabs.clear();
 }
 
 void KMultiTabBarInternal::setStyle(enum KMultiTabBar::KMultiTabBarStyle style)
 {
     m_style = style;
     for (int i = 0; i < m_tabs.count(); i++) {
         m_tabs.at(i)->setStyle(m_style);
     }
 
     updateGeometry();
 }
 
 void KMultiTabBarInternal::contentsMousePressEvent(QMouseEvent *ev)
 {
     ev->ignore();
 }
 
 void KMultiTabBarInternal::mousePressEvent(QMouseEvent *ev)
 {
     ev->ignore();
 }
 
 KMultiTabBarTab *KMultiTabBarInternal::tab(int id) const
 {
     QListIterator<KMultiTabBarTab *> it(m_tabs);
     while (it.hasNext()) {
         KMultiTabBarTab *tab = it.next();
         if (tab->id() == id) {
             return tab;
         }
     }
     return nullptr;
 }
 
 int KMultiTabBarInternal::appendTab(const QIcon &icon, int id, const QString &text)
 {
     KMultiTabBarTab *tab;
     m_tabs.append(tab = new KMultiTabBarTab(icon, text, id, this, m_position, m_style));
 
     // Insert before the stretch..
     mainLayout->insertWidget(m_tabs.size() - 1, tab);
     tab->show();
     return 0;
 }
 
 int KMultiTabBarInternal::appendTab(const QPixmap &pic, int id, const QString &text)
 {
     // reuse icon variant
     return appendTab(QIcon(pic), id, text);
 }
 
 void KMultiTabBarInternal::removeTab(int id)
 {
     for (int pos = 0; pos < m_tabs.count(); pos++) {
         if (m_tabs.at(pos)->id() == id) {
             // remove & delete the tab
             delete m_tabs.takeAt(pos);
             break;
         }
     }
 }
 
 void KMultiTabBarInternal::setPosition(enum KMultiTabBar::KMultiTabBarPosition pos)
 {
     m_position = pos;
     for (int i = 0; i < m_tabs.count(); i++) {
         m_tabs.at(i)->setPosition(m_position);
     }
     updateGeometry();
 }
 
 // KMultiTabBarButton
 ///////////////////////////////////////////////////////////////////////////////
 
 KMultiTabBarButton::KMultiTabBarButton(const QIcon &icon, const QString &text, int id, QWidget *parent)
     : QPushButton(icon, text, parent)
     , m_id(id)
     , d(nullptr)
 {
     connect(this, &QPushButton::clicked, this, &KMultiTabBarButton::slotClicked);
 
     // we can't see the focus, so don't take focus. #45557
     // If keyboard navigation is wanted, then only the bar should take focus,
     // and arrows could change the focused button; but generally, tabbars don't take focus anyway.
     setFocusPolicy(Qt::NoFocus);
     setAttribute(Qt::WA_LayoutUsesWidgetRect);
     Q_UNUSED(d);
 }
 
 KMultiTabBarButton::~KMultiTabBarButton()
 {
 }
 
 void KMultiTabBarButton::setText(const QString &text)
 {
     QPushButton::setText(text);
 }
 
 void KMultiTabBarButton::slotClicked()
 {
     updateGeometry();
     Q_EMIT clicked(m_id);
 }
 
 int KMultiTabBarButton::id() const
 {
     return m_id;
 }
 
 void KMultiTabBarButton::hideEvent(QHideEvent *he)
 {
     QPushButton::hideEvent(he);
     KMultiTabBar *tb = dynamic_cast<KMultiTabBar *>(parentWidget());
     if (tb) {
         tb->updateSeparator();
     }
 }
 
 void KMultiTabBarButton::showEvent(QShowEvent *he)
 {
     QPushButton::showEvent(he);
     KMultiTabBar *tb = dynamic_cast<KMultiTabBar *>(parentWidget());
     if (tb) {
         tb->updateSeparator();
     }
 }
 
 void KMultiTabBarButton::paintEvent(QPaintEvent *)
 {
     QStyleOptionButton opt;
     opt.initFrom(this);
     opt.icon = icon();
     opt.iconSize = iconSize();
     // removes the QStyleOptionButton::HasMenu ButtonFeature
     opt.features = QStyleOptionButton::Flat;
     QPainter painter(this);
     style()->drawControl(QStyle::CE_PushButton, &opt, &painter, this);
 }
 
 // KMultiTabBarTab
 ///////////////////////////////////////////////////////////////////////////////
 
 KMultiTabBarTab::KMultiTabBarTab(const QIcon &icon,
                                  const QString &text,
                                  int id,
                                  QWidget *parent,
                                  KMultiTabBar::KMultiTabBarPosition pos,
                                  KMultiTabBar::KMultiTabBarStyle style)
     : KMultiTabBarButton(icon, text, id, parent)
     , m_style(style)
     , d(nullptr)
 {
     m_position = pos;
     setToolTip(text);
     setCheckable(true);
     // shrink down to icon only, but prefer to show text if it's there
     setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
 }
 
 KMultiTabBarTab::~KMultiTabBarTab()
 {
 }
 
 void KMultiTabBarTab::setPosition(KMultiTabBar::KMultiTabBarPosition pos)
 {
     m_position = pos;
     updateGeometry();
 }
 
 void KMultiTabBarTab::setStyle(KMultiTabBar::KMultiTabBarStyle style)
 {
     m_style = style;
     updateGeometry();
 }
 
 void KMultiTabBarTab::initStyleOption(QStyleOptionToolButton *opt) const
 {
     opt->initFrom(this);
 
     // Setup icon..
     if (!icon().isNull()) {
         opt->iconSize = iconSize();
         opt->icon = icon();
     }
 
     // Should we draw text?
     if (shouldDrawText()) {
         opt->text = text();
     }
 
     opt->state |= QStyle::State_AutoRaise;
     if (!isChecked() && !isDown()) {
         opt->state |= QStyle::State_Raised;
     }
     if (isDown()) {
         opt->state |= QStyle::State_Sunken;
     }
     if (isChecked()) {
         opt->state |= QStyle::State_On;
     }
 
     opt->font = font();
     opt->toolButtonStyle = shouldDrawText() ? Qt::ToolButtonTextBesideIcon : Qt::ToolButtonIconOnly;
     opt->subControls = QStyle::SC_ToolButton;
 }
 
 QSize KMultiTabBarTab::sizeHint() const
 {
     return computeSizeHint(shouldDrawText());
 }
 
 QSize KMultiTabBarTab::minimumSizeHint() const
 {
     return computeSizeHint(false);
 }
 
 void KMultiTabBarTab::computeMargins(int *hMargin, int *vMargin) const
 {
     // Unfortunately, QStyle does not give us enough information to figure out
     // where to place things, so we try to reverse-engineer it
     QStyleOptionToolButton opt;
     initStyleOption(&opt);
 
     QSize trialSize = opt.iconSize;
     QSize expandSize = style()->sizeFromContents(QStyle::CT_ToolButton, &opt, trialSize, this);
 
     *hMargin = (expandSize.width() - trialSize.width()) / 2;
     *vMargin = (expandSize.height() - trialSize.height()) / 2;
 }
 
 QSize KMultiTabBarTab::computeSizeHint(bool withText) const
 {
     // Compute as horizontal first, then flip around if need be.
     QStyleOptionToolButton opt;
     initStyleOption(&opt);
 
     int hMargin;
     int vMargin;
     computeMargins(&hMargin, &vMargin);
 
     // Compute interior size, starting from pixmap..
     QSize size = opt.iconSize;
 
     // Always include text height in computation, to avoid resizing the minor direction
     // when expanding text..
     QSize textSize = fontMetrics().size(0, text());
     size.setHeight(qMax(size.height(), textSize.height()));
 
     // Pick margins for major/minor direction, depending on orientation
     int majorMargin = isVertical() ? vMargin : hMargin;
     int minorMargin = isVertical() ? hMargin : vMargin;
 
     size.setWidth(size.width() + 2 * majorMargin);
     size.setHeight(size.height() + 2 * minorMargin);
 
     if (withText && !text().isEmpty())
     // Add enough room for the text, and an extra major margin.
     {
         size.setWidth(size.width() + textSize.width() + majorMargin);
     }
 
     // flip time?
     if (isVertical()) {
         return QSize(size.height(), size.width());
     } else {
         return size;
     }
 }
 
 void KMultiTabBarTab::setState(bool newState)
 {
     setChecked(newState);
     updateGeometry();
 }
 
 bool KMultiTabBarTab::shouldDrawText() const
 {
     return (m_style == KMultiTabBar::KDEV3ICON) || isChecked();
 }
 
 bool KMultiTabBarTab::isVertical() const
 {
     return m_position == KMultiTabBar::Right || m_position == KMultiTabBar::Left;
 }
 
 void KMultiTabBarTab::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
 
     QStyleOptionToolButton opt;
     initStyleOption(&opt);
 
     // Paint bevel..
     if (underMouse() || isChecked()) {
         opt.text.clear();
         opt.icon = QIcon();
         style()->drawComplexControl(QStyle::CC_ToolButton, &opt, &painter, this);
     }
 
     int hMargin;
     int vMargin;
     computeMargins(&hMargin, &vMargin);
 
     // We first figure out how much room we have for the text, based on
     // icon size and margin, try to fit in by eliding, and perhaps
     // give up on drawing the text entirely if we're too short on room
     int textRoom = 0;
     int iconRoom = 0;
 
     QString t;
     if (shouldDrawText()) {
         if (isVertical()) {
             iconRoom = opt.iconSize.height() + 2 * vMargin;
             textRoom = height() - iconRoom - vMargin;
         } else {
             iconRoom = opt.iconSize.width() + 2 * hMargin;
             textRoom = width() - iconRoom - hMargin;
         }
 
         t = painter.fontMetrics().elidedText(text(), Qt::ElideRight, textRoom);
 
         // See whether anything is left. Qt will return either
         // ... or the ellipsis unicode character, 0x2026
         if (t == QLatin1String("...") || t == QChar(0x2026)) {
             t.clear();
         }
     }
 
     const QIcon::Mode iconMode = (opt.state & QStyle::State_MouseOver) ? QIcon::Active : QIcon::Normal;
     const QPixmap iconPixmap = icon().pixmap(opt.iconSize, devicePixelRatioF(), iconMode, QIcon::On);
 
     // Label time.... Simple case: no text, so just plop down the icon right in the center
     // We only do this when the button never draws the text, to avoid jumps in icon position
     // when resizing
     if (!shouldDrawText()) {
         style()->drawItemPixmap(&painter, rect(), Qt::AlignCenter | Qt::AlignVCenter, iconPixmap);
         return;
     }
 
     // Now where the icon/text goes depends on text direction and tab position
     QRect iconArea;
     QRect labelArea;
 
     bool bottomIcon = false;
     bool rtl = layoutDirection() == Qt::RightToLeft;
     if (isVertical()) {
         if (m_position == KMultiTabBar::Left && !rtl) {
             bottomIcon = true;
         }
         if (m_position == KMultiTabBar::Right && rtl) {
             bottomIcon = true;
         }
     }
     // alignFlags = Qt::AlignLeading | Qt::AlignVCenter;
 
     const int iconXShift = (isChecked() || isDown()) ? style()->pixelMetric(QStyle::PM_ButtonShiftHorizontal, &opt, this) : 0;
     const int iconYShift = (isChecked() || isDown()) ? style()->pixelMetric(QStyle::PM_ButtonShiftVertical, &opt, this) : 0;
     if (isVertical()) {
         if (bottomIcon) {
             labelArea = QRect(0, vMargin, width(), textRoom);
             iconArea = QRect(0, vMargin + textRoom, width(), iconRoom);
             iconArea.translate(iconYShift, -iconXShift);
         } else {
             labelArea = QRect(0, iconRoom, width(), textRoom);
             iconArea = QRect(0, 0, width(), iconRoom);
             iconArea.translate(-iconYShift, iconXShift);
         }
     } else {
         // Pretty simple --- depends only on RTL/LTR
         if (rtl) {
             labelArea = QRect(hMargin, 0, textRoom, height());
             iconArea = QRect(hMargin + textRoom, 0, iconRoom, height());
         } else {
             labelArea = QRect(iconRoom, 0, textRoom, height());
             iconArea = QRect(0, 0, iconRoom, height());
         }
         iconArea.translate(iconXShift, iconYShift);
     }
 
     style()->drawItemPixmap(&painter, iconArea, Qt::AlignCenter | Qt::AlignVCenter, iconPixmap);
 
     if (t.isEmpty()) {
         return;
     }
 
     QRect labelPaintArea = labelArea;
 
     if (isVertical()) {
         // If we're vertical, we paint to a simple 0,0 origin rect,
         // and get the transformations to get us in the right place
         labelPaintArea = QRect(0, 0, labelArea.height(), labelArea.width());
 
         QTransform tr;
 
         if (bottomIcon) {
             tr.translate(labelArea.x(), labelPaintArea.width() + labelArea.y());
             tr.rotate(-90);
         } else {
             tr.translate(labelPaintArea.height() + labelArea.x(), labelArea.y());
             tr.rotate(90);
         }
         painter.setTransform(tr);
     }
 
     opt.text = t;
     opt.icon = QIcon();
     opt.rect = labelPaintArea;
     style()->drawControl(QStyle::CE_ToolButtonLabel, &opt, &painter, this);
 }
 
 // KMultiTabBar
 ///////////////////////////////////////////////////////////////////////////////
 
 KMultiTabBar::KMultiTabBar(QWidget *parent)
     : KMultiTabBar(Left, parent)
 {
 }
 
 KMultiTabBar::KMultiTabBar(KMultiTabBarPosition pos, QWidget *parent)
     : QWidget(parent)
     , d(new KMultiTabBarPrivate)
 {
     if (pos == Left || pos == Right) {
         d->m_l = new QVBoxLayout(this);
         setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding /*, true*/);
     } else {
         d->m_l = new QHBoxLayout(this);
         setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed /*, true*/);
     }
     d->m_l->setContentsMargins(0, 0, 0, 0);
     d->m_l->setSpacing(0);
 
     d->m_internal = new KMultiTabBarInternal(this, pos);
     setPosition(pos);
     setStyle(VSNET);
     d->m_l->insertWidget(0, d->m_internal);
     d->m_l->insertWidget(0, d->m_btnTabSep = new QFrame(this));
     d->m_btnTabSep->setFixedHeight(4);
     d->m_btnTabSep->setFrameStyle(QFrame::Panel | QFrame::Sunken);
     d->m_btnTabSep->setLineWidth(2);
     d->m_btnTabSep->hide();
 
     updateGeometry();
 }
 
 KMultiTabBar::~KMultiTabBar()
 {
     qDeleteAll(d->m_buttons);
     d->m_buttons.clear();
 }
 
 int KMultiTabBar::appendButton(const QIcon &icon, int id, QMenu *popup, const QString &)
 {
     KMultiTabBarButton *btn = new KMultiTabBarButton(icon, QString(), id, this);
     // a button with a QMenu can have another size. Make sure the button has always the same size.
     btn->setFixedWidth(btn->height());
     btn->setMenu(popup);
     d->m_buttons.append(btn);
     d->m_l->insertWidget(0, btn);
     btn->show();
     d->m_btnTabSep->show();
     return 0;
 }
 
 void KMultiTabBar::updateSeparator()
 {
     bool hideSep = true;
     QListIterator<KMultiTabBarButton *> it(d->m_buttons);
     while (it.hasNext()) {
         if (it.next()->isVisibleTo(this)) {
             hideSep = false;
             break;
         }
     }
     if (hideSep) {
         d->m_btnTabSep->hide();
     } else {
         d->m_btnTabSep->show();
     }
 }
 
 int KMultiTabBar::appendTab(const QIcon &icon, int id, const QString &text)
 {
     d->m_internal->appendTab(icon, id, text);
     return 0;
 }
 
 KMultiTabBarButton *KMultiTabBar::button(int id) const
 {
     QListIterator<KMultiTabBarButton *> it(d->m_buttons);
     while (it.hasNext()) {
         KMultiTabBarButton *button = it.next();
         if (button->id() == id) {
             return button;
         }
     }
 
     return nullptr;
 }
 
 KMultiTabBarTab *KMultiTabBar::tab(int id) const
 {
     return d->m_internal->tab(id);
 }
 
 void KMultiTabBar::removeButton(int id)
 {
     for (int pos = 0; pos < d->m_buttons.count(); pos++) {
         if (d->m_buttons.at(pos)->id() == id) {
             d->m_buttons.takeAt(pos)->deleteLater();
             break;
         }
     }
 
     if (d->m_buttons.isEmpty()) {
         d->m_btnTabSep->hide();
     }
 }
 
 void KMultiTabBar::removeTab(int id)
 {
     d->m_internal->removeTab(id);
 }
 
 void KMultiTabBar::setTab(int id, bool state)
 {
     KMultiTabBarTab *ttab = tab(id);
     if (ttab) {
         ttab->setState(state);
     }
 }
 
 bool KMultiTabBar::isTabRaised(int id) const
 {
     KMultiTabBarTab *ttab = tab(id);
     if (ttab) {
         return ttab->isChecked();
     }
 
     return false;
 }
 
 void KMultiTabBar::setStyle(KMultiTabBarStyle style)
 {
     d->m_internal->setStyle(style);
 }
 
 KMultiTabBar::KMultiTabBarStyle KMultiTabBar::tabStyle() const
 {
     return d->m_internal->m_style;
 }
 
 void KMultiTabBar::setPosition(KMultiTabBarPosition pos)
 {
     d->m_position = pos;
     d->m_internal->setPosition(pos);
 }
 
 KMultiTabBar::KMultiTabBarPosition KMultiTabBar::position() const
 {
     return d->m_position;
 }
 
 void KMultiTabBar::fontChange(const QFont & /* oldFont */)
 {
     updateGeometry();
 }
 
 void KMultiTabBar::paintEvent(class QPaintEvent *)
 {
     // By default plain QWidget don't call the QStyle and are transparent
     // using drawPrimitive(QStyle::PE_Widget) allow QStyle implementation
     // to theme this class.
     QPainter painter(this);
     QStyleOption opt;
     opt.initFrom(this);
     style()->drawPrimitive(QStyle::PE_Widget, &opt, &painter, this);
 }