File indexing completed on 2024-04-28 08:51:04

 /*
     SPDX-FileCopyrightText: 2009 Tony Murray <murraytony@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "tabbedviewwidget.h"
 #include "krdc_debug.h"
 
 #include <QRegularExpression>
 #include <QTabBar>
 
 TabbedViewWidgetModel::TabbedViewWidgetModel(QTabWidget *modelTarget)
         : QAbstractItemModel(modelTarget), m_tabWidget(modelTarget)
 {
 }
 
 QModelIndex TabbedViewWidgetModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent)) {
         return QModelIndex();
     }
     return createIndex(row, column, m_tabWidget->widget(row));
 }
 
 QModelIndex TabbedViewWidgetModel::parent(const QModelIndex &) const
 {
     return QModelIndex();
 }
 
 int TabbedViewWidgetModel::columnCount(const QModelIndex &) const
 {
     return 1;
 }
 
 int TabbedViewWidgetModel::rowCount(const QModelIndex &) const
 {
     return m_tabWidget->count();
 }
 
 Qt::ItemFlags TabbedViewWidgetModel::flags(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return Qt::ItemIsEnabled;
     }
     return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
 }
 
 bool TabbedViewWidgetModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (index.isValid() && role == Qt::EditRole) {
         m_tabWidget->setTabText(index.row(), value.toString());
         Q_EMIT dataChanged(index, index);
         return true;
     }
     return false;
 }
 
 QVariant TabbedViewWidgetModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     switch (role) {
     case Qt::EditRole:
     case Qt::DisplayRole: {
         static QRegularExpression reg(QStringLiteral("&(?!&)"));
         return m_tabWidget->tabText(index.row()).remove(reg); //remove accelerator string
     }
     case Qt::ToolTipRole:
         return m_tabWidget->tabToolTip(index.row());
     case Qt::DecorationRole:
         return m_tabWidget->tabIcon(index.row());
     default:
         return QVariant();
     }
 }
 
 void TabbedViewWidgetModel::emitLayoutAboutToBeChanged()
 {
     Q_EMIT layoutAboutToBeChanged();
 }
 
 void TabbedViewWidgetModel::emitLayoutChanged()
 {
     Q_EMIT layoutChanged();
 }
 
 void TabbedViewWidgetModel::emitDataChanged(int index)
 {
     QModelIndex modelIndex = createIndex(index, 1);
     Q_EMIT dataChanged(modelIndex, modelIndex);
 }
 
 TabbedViewWidget::TabbedViewWidget(QWidget *parent)
         : QTabWidget(parent), m_model(new TabbedViewWidgetModel(this))
 {
 }
 
 TabbedViewWidget::~TabbedViewWidget()
 {
 }
 
 TabbedViewWidgetModel* TabbedViewWidget::getModel()
 {
     return m_model;
 }
 
 int TabbedViewWidget::addTab(QWidget *page, const QString &label)
 {
     int count = QTabWidget::count();
     m_model->beginInsertRows(QModelIndex(), count, count);
     int ret = QTabWidget::addTab(page, label);
     m_model->endInsertRows();
     return ret;
 }
 
 int TabbedViewWidget::addTab(QWidget *page, const QIcon &icon, const QString &label)
 {
     int count = QTabWidget::count();
     m_model->beginInsertRows(QModelIndex(), count, count);
     int ret = QTabWidget::addTab(page, icon, label);
     m_model->endInsertRows();
     return ret;
 }
 
 int TabbedViewWidget::insertTab(int index, QWidget *page, const QString &label)
 {
     m_model->beginInsertRows(QModelIndex(), index, index);
     int ret = QTabWidget::insertTab(index, page, label);
     m_model->endInsertRows();
     return ret;
 }
 
 int TabbedViewWidget::insertTab(int index, QWidget *page, const QIcon &icon, const QString &label)
 {
     m_model->beginInsertRows(QModelIndex(), index, index);
     int ret = QTabWidget::insertTab(index, page, icon, label);
     m_model->endInsertRows();
     return ret;
 }
 
 void TabbedViewWidget::removePage(QWidget *page)
 {
     int index = QTabWidget::indexOf(page);
     if (index == -1) {
         return;
     }
     m_model->beginRemoveRows(QModelIndex(), index, index);
     QTabWidget::removeTab(index);
     m_model->endRemoveRows();
 }
 
 void TabbedViewWidget::removeTab(int index)
 {
     m_model->beginRemoveRows(QModelIndex(), index, index);
     QTabWidget::removeTab(index);
     m_model->endRemoveRows();
 }
 
 void TabbedViewWidget::moveTab(int from, int to)
 {
     m_model->emitLayoutAboutToBeChanged();
     tabBar()->moveTab(from, to);
     m_model->emitLayoutChanged();
 }
 
 void TabbedViewWidget::setTabText(int index, const QString &label)
 {
     QTabWidget::setTabText(index, label);
     m_model->emitDataChanged(index);
 }
 
 //This functionality is taken from  KTabWidget for compatibility.
 //KTabWidget has been moved to KdeLibs4Support and QTabWidget::tabBarDoubleClicked does not
 //work on empty space after tabs,
 bool TabbedViewWidget::isEmptyTabbarSpace(const QPoint &point) const
 {
     if (count() == 0) {
         return true;
     }
     if (tabBar()->isHidden()) {
         return false;
     }
     QSize size(tabBar()->sizeHint());
     if ((tabPosition() == QTabWidget::North && point.y() < size.height()) ||
             (tabPosition() == QTabWidget::South && point.y() > (height() - size.height()))) {
 
         QWidget *rightcorner = cornerWidget(Qt::TopRightCorner);
         if (rightcorner && rightcorner->isVisible()) {
             if (point.x() >= width() - rightcorner->width()) {
                 return false;
             }
         }
 
         QWidget *leftcorner = cornerWidget(Qt::TopLeftCorner);
         if (leftcorner && leftcorner->isVisible()) {
             if (point.x() <= leftcorner->width()) {
                 return false;
             }
         }
 
         for (int i = 0; i < count(); ++i)
             if (tabBar()->tabRect(i).contains(tabBar()->mapFromParent(point))) {
                 return false;
             }
 
         return true;
     }
 
     return false;
 }
 
 void TabbedViewWidget::mouseDoubleClickEvent(QMouseEvent * event)
 {
     if (event->button() != Qt::LeftButton) {
         return;
     }
 
     if (isEmptyTabbarSpace(event->pos())) {
         Q_EMIT tabBarDoubleClicked(-1);
         return;
     }
 
     QTabWidget::mouseDoubleClickEvent(event);
 }
 
 void TabbedViewWidget::mouseReleaseEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::MiddleButton) {
         if (isEmptyTabbarSpace(event->pos())) {
             Q_EMIT mouseMiddleClick(-1);
             return;
         }
         int pos = tabBar()->tabAt(event->pos());
         if(pos != -1){
             Q_EMIT mouseMiddleClick(pos);
             return;
         }
     }
 
     QTabWidget::mouseReleaseEvent(event);
 }