File indexing completed on 2024-05-19 03:59:08

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 1999 Simon Hausmann <hausmann@kde.org>
     SPDX-FileCopyrightText: 1999 David Faure <faure@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "partmanager.h"
 
 #include "guiactivateevent.h"
 #include "kparts_logging.h"
 #include "part.h"
 #include "partactivateevent.h"
 
 #include <QApplication>
 #include <QMouseEvent>
 #include <QScrollBar>
 
 using namespace KParts;
 
 namespace KParts
 {
 class PartManagerPrivate
 {
 public:
     PartManagerPrivate()
     {
         m_activeWidget = nullptr;
         m_activePart = nullptr;
         m_bAllowNestedParts = false;
         m_bIgnoreScrollBars = false;
         m_activationButtonMask = Qt::LeftButton | Qt::MiddleButton | Qt::RightButton;
         m_reason = PartManager::NoReason;
         m_bIgnoreExplicitFocusRequest = false;
     }
     ~PartManagerPrivate()
     {
     }
     void setReason(QEvent *ev)
     {
         switch (ev->type()) {
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonDblClick: {
             // clang-format off
             QMouseEvent *mev = static_cast<QMouseEvent *>(ev);
             m_reason = mev->button() == Qt::LeftButton
                        ? PartManager::ReasonLeftClick
                        : (mev->button() == Qt::MiddleButton
                           ? PartManager::ReasonMidClick
                           : PartManager::ReasonRightClick);
             // clang-format on
             break;
         }
         case QEvent::FocusIn:
             m_reason = static_cast<QFocusEvent *>(ev)->reason();
             break;
         default:
             qCWarning(KPARTSLOG) << "PartManagerPrivate::setReason got unexpected event type" << ev->type();
             break;
         }
     }
 
     bool allowExplicitFocusEvent(QEvent *ev) const
     {
         if (ev->type() == QEvent::FocusIn) {
             QFocusEvent *fev = static_cast<QFocusEvent *>(ev);
             return (!m_bIgnoreExplicitFocusRequest || fev->reason() != Qt::OtherFocusReason);
         }
         return true;
     }
 
     Part *m_activePart;
     QWidget *m_activeWidget;
 
     QList<Part *> m_parts;
 
     PartManager::SelectionPolicy m_policy;
 
     QList<const QWidget *> m_managedTopLevelWidgets;
     short int m_activationButtonMask;
     bool m_bIgnoreScrollBars;
     bool m_bAllowNestedParts;
     int m_reason;
     bool m_bIgnoreExplicitFocusRequest;
 };
 
 }
 
 PartManager::PartManager(QWidget *parent)
     : QObject(parent)
     , d(new PartManagerPrivate)
 {
     qApp->installEventFilter(this);
 
     d->m_policy = Direct;
 
     addManagedTopLevelWidget(parent);
 }
 
 PartManager::PartManager(QWidget *topLevel, QObject *parent)
     : QObject(parent)
     , d(new PartManagerPrivate)
 {
     qApp->installEventFilter(this);
 
     d->m_policy = Direct;
 
     addManagedTopLevelWidget(topLevel);
 }
 
 PartManager::~PartManager()
 {
     for (const QWidget *w : std::as_const(d->m_managedTopLevelWidgets)) {
         disconnect(w, &QWidget::destroyed, this, &PartManager::slotManagedTopLevelWidgetDestroyed);
     }
 
     for (Part *it : std::as_const(d->m_parts)) {
         it->setManager(nullptr);
     }
 
     // core dumps ... setActivePart( 0 );
     qApp->removeEventFilter(this);
 }
 
 void PartManager::setSelectionPolicy(SelectionPolicy policy)
 {
     d->m_policy = policy;
 }
 
 PartManager::SelectionPolicy PartManager::selectionPolicy() const
 {
     return d->m_policy;
 }
 
 void PartManager::setAllowNestedParts(bool allow)
 {
     d->m_bAllowNestedParts = allow;
 }
 
 bool PartManager::allowNestedParts() const
 {
     return d->m_bAllowNestedParts;
 }
 
 void PartManager::setIgnoreScrollBars(bool ignore)
 {
     d->m_bIgnoreScrollBars = ignore;
 }
 
 bool PartManager::ignoreScrollBars() const
 {
     return d->m_bIgnoreScrollBars;
 }
 
 void PartManager::setActivationButtonMask(short int buttonMask)
 {
     d->m_activationButtonMask = buttonMask;
 }
 
 short int PartManager::activationButtonMask() const
 {
     return d->m_activationButtonMask;
 }
 
 bool PartManager::eventFilter(QObject *obj, QEvent *ev)
 {
     if (ev->type() != QEvent::MouseButtonPress && ev->type() != QEvent::MouseButtonDblClick && ev->type() != QEvent::FocusIn) {
         return false;
     }
 
     if (!obj->isWidgetType()) {
         return false;
     }
 
     QWidget *w = static_cast<QWidget *>(obj);
 
     if (((w->windowFlags().testFlag(Qt::Dialog)) && w->isModal()) || (w->windowFlags().testFlag(Qt::Popup)) || (w->windowFlags().testFlag(Qt::Tool))) {
         return false;
     }
 
     QMouseEvent *mev = nullptr;
     if (ev->type() == QEvent::MouseButtonPress || ev->type() == QEvent::MouseButtonDblClick) {
         mev = static_cast<QMouseEvent *>(ev);
 
         qCDebug(KPARTSLOG) << "PartManager::eventFilter button:" << mev->button() << "d->m_activationButtonMask=" << d->m_activationButtonMask;
 
         if ((mev->button() & d->m_activationButtonMask) == 0) {
             return false; // ignore this button
         }
     }
 
     Part *part;
     while (w) {
         QPoint pos;
 
         if (!d->m_managedTopLevelWidgets.contains(w->topLevelWidget())) {
             return false;
         }
 
         if (d->m_bIgnoreScrollBars && ::qobject_cast<QScrollBar *>(w)) {
             return false;
         }
 
         if (mev) { // mouse press or mouse double-click event
             pos = mev->globalPosition().toPoint();
             part = findPartFromWidget(w, pos);
         } else {
             part = findPartFromWidget(w);
         }
 
         // clang-format off
         const char *evType = (ev->type() == QEvent::MouseButtonPress) ? "MouseButtonPress"
                              : (ev->type() == QEvent::MouseButtonDblClick) ? "MouseButtonDblClick"
                              : (ev->type() == QEvent::FocusIn) ? "FocusIn" : "OTHER! ERROR!";
         // clang-format on
         if (part) { // We found a part whose widget is w
             if (d->m_policy == PartManager::TriState) {
                 if (ev->type() == QEvent::MouseButtonDblClick) {
                     if (part == d->m_activePart && w == d->m_activeWidget) {
                         return false;
                     }
 
                     qCDebug(KPARTSLOG) << "PartManager::eventFilter dblclick -> setActivePart" << part;
 
                     d->setReason(ev);
                     setActivePart(part, w);
                     d->m_reason = NoReason;
                     return true;
                 }
 
                 if ((d->m_activeWidget != w || d->m_activePart != part)) {
                     qCDebug(KPARTSLOG) << "Part" << part << "(non-selectable) made active because" << w->metaObject()->className() << "got event" << evType;
 
                     d->setReason(ev);
                     setActivePart(part, w);
                     d->m_reason = NoReason;
                     return true;
                 } else if (d->m_activeWidget == w && d->m_activePart == part) {
                     return false;
                 }
 
                 return false;
             } else if (part != d->m_activePart && d->allowExplicitFocusEvent(ev)) {
                 qCDebug(KPARTSLOG) << "Part" << part << "made active because" << w->metaObject()->className() << "got event" << evType;
 
                 d->setReason(ev);
                 setActivePart(part, w);
                 d->m_reason = NoReason;
             }
 
             return false;
         }
 
         w = w->parentWidget();
 
         if (w && (((w->windowFlags() & Qt::Dialog) && w->isModal()) || (w->windowFlags() & Qt::Popup) || (w->windowFlags() & Qt::Tool))) {
             qCDebug(KPARTSLOG) << "No part made active although" << obj->objectName() << "/" << obj->metaObject()->className() << "got event - loop aborted";
 
             return false;
         }
     }
 
     qCDebug(KPARTSLOG) << "No part made active although" << obj->objectName() << "/" << obj->metaObject()->className() << "got event - loop aborted";
 
     return false;
 }
 
 Part *PartManager::findPartFromWidget(QWidget *widget, const QPoint &pos)
 {
     for (auto *p : std::as_const(d->m_parts)) {
         Part *part = p->hitTest(widget, pos);
         if (part && d->m_parts.contains(part)) {
             return part;
         }
     }
     return nullptr;
 }
 
 Part *PartManager::findPartFromWidget(QWidget *widget)
 {
     for (auto *part : std::as_const(d->m_parts)) {
         if (widget == part->widget()) {
             return part;
         }
     }
     return nullptr;
 }
 
 void PartManager::addPart(Part *part, bool setActive)
 {
     Q_ASSERT(part);
 
     // don't add parts more than once :)
     if (d->m_parts.contains(part)) {
         qCWarning(KPARTSLOG) << part << " already added";
         return;
     }
 
     d->m_parts.append(part);
 
     part->setManager(this);
 
     if (setActive) {
         setActivePart(part);
 
         if (QWidget *w = part->widget()) {
             // Prevent focus problems
             if (w->focusPolicy() == Qt::NoFocus) {
                 qCWarning(KPARTSLOG) << "Part '" << part->objectName() << "' has a widget " << w->objectName()
                                      << "with a focus policy of NoFocus. It should have at least a"
                                      << "ClickFocus policy, for part activation to work well.";
             }
             if (part->widget() && part->widget()->focusPolicy() == Qt::TabFocus) {
                 qCWarning(KPARTSLOG) << "Part '" << part->objectName() << "' has a widget " << w->objectName()
                                      << "with a focus policy of TabFocus. It should have at least a"
                                      << "ClickFocus policy, for part activation to work well.";
             }
             w->setFocus();
             w->show();
         }
     }
     Q_EMIT partAdded(part);
 }
 
 void PartManager::removePart(Part *part)
 {
     if (!d->m_parts.contains(part)) {
         return;
     }
 
     const int nb = d->m_parts.removeAll(part);
     Q_ASSERT(nb == 1);
     Q_UNUSED(nb); // no warning in release mode
     part->setManager(nullptr);
 
     Q_EMIT partRemoved(part);
 
     if (part == d->m_activePart) {
         setActivePart(nullptr);
     }
 }
 
 void PartManager::replacePart(Part *oldPart, Part *newPart, bool setActive)
 {
     // qCDebug(KPARTSLOG) << "replacePart" << oldPart->name() << "->" << newPart->name() << "setActive=" << setActive;
     // This methods does exactly removePart + addPart but without calling setActivePart(0) in between
     if (!d->m_parts.contains(oldPart)) {
         qFatal("Can't remove part %s, not in KPartManager's list.", oldPart->objectName().toLocal8Bit().constData());
         return;
     }
 
     d->m_parts.removeAll(oldPart);
     oldPart->setManager(nullptr);
 
     Q_EMIT partRemoved(oldPart);
 
     addPart(newPart, setActive);
 }
 
 void PartManager::setActivePart(Part *part, QWidget *widget)
 {
     if (part && !d->m_parts.contains(part)) {
         qCWarning(KPARTSLOG) << "trying to activate a non-registered part!" << part->objectName();
         return; // don't allow someone call setActivePart with a part we don't know about
     }
 
     // check whether nested parts are disallowed and activate the top parent part then, by traversing the
     // tree recursively (Simon)
     if (part && !d->m_bAllowNestedParts) {
         QObject *parentPart = part->parent(); // ### this relies on people using KParts::Factory!
         KParts::Part *parPart = ::qobject_cast<KParts::Part *>(parentPart);
         if (parPart) {
             setActivePart(parPart, parPart->widget());
             return;
         }
     }
 
     qCDebug(KPARTSLOG) << "PartManager::setActivePart d->m_activePart=" << d->m_activePart << "<->part=" << part << "d->m_activeWidget=" << d->m_activeWidget
                        << "<->widget=" << widget;
 
     // don't activate twice
     if (d->m_activePart && part && d->m_activePart == part && (!widget || d->m_activeWidget == widget)) {
         return;
     }
 
     KParts::Part *oldActivePart = d->m_activePart;
     QWidget *oldActiveWidget = d->m_activeWidget;
 
     d->m_activePart = part;
     d->m_activeWidget = widget;
 
     if (oldActivePart) {
         KParts::Part *savedActivePart = part;
         QWidget *savedActiveWidget = widget;
 
         PartActivateEvent ev(false, oldActivePart, oldActiveWidget);
         QApplication::sendEvent(oldActivePart, &ev);
         if (oldActiveWidget) {
             disconnect(oldActiveWidget, &QWidget::destroyed, this, &PartManager::slotWidgetDestroyed);
             QApplication::sendEvent(oldActiveWidget, &ev);
         }
 
         d->m_activePart = savedActivePart;
         d->m_activeWidget = savedActiveWidget;
     }
 
     if (d->m_activePart) {
         if (!widget) {
             d->m_activeWidget = part->widget();
         }
 
         PartActivateEvent ev(true, d->m_activePart, d->m_activeWidget);
         QApplication::sendEvent(d->m_activePart, &ev);
         if (d->m_activeWidget) {
             connect(d->m_activeWidget, &QWidget::destroyed, this, &PartManager::slotWidgetDestroyed);
             QApplication::sendEvent(d->m_activeWidget, &ev);
         }
     }
     // Set the new active instance
     // setActiveComponent(d->m_activePart ? d->m_activePart->componentData() : KComponentData::mainComponent());
 
     qCDebug(KPARTSLOG) << this << "emitting activePartChanged" << d->m_activePart;
 
     Q_EMIT activePartChanged(d->m_activePart);
 }
 
 Part *PartManager::activePart() const
 {
     return d->m_activePart;
 }
 
 QWidget *PartManager::activeWidget() const
 {
     return d->m_activeWidget;
 }
 
 void PartManager::slotObjectDestroyed()
 {
     // qDebug();
     removePart(const_cast<Part *>(static_cast<const Part *>(sender())));
 }
 
 void PartManager::slotWidgetDestroyed()
 {
     // qDebug();
     if (static_cast<const QWidget *>(sender()) == d->m_activeWidget) {
         setActivePart(nullptr); // do not remove the part because if the part's widget dies, then the
     }
     // part will delete itself anyway, invoking removePart() in its destructor
 }
 
 const QList<Part *> PartManager::parts() const
 {
     return d->m_parts;
 }
 
 void PartManager::addManagedTopLevelWidget(const QWidget *topLevel)
 {
     if (!topLevel->isWindow()) {
         return;
     }
 
     if (d->m_managedTopLevelWidgets.contains(topLevel)) {
         return;
     }
 
     d->m_managedTopLevelWidgets.append(topLevel);
     connect(topLevel, &QWidget::destroyed, this, &PartManager::slotManagedTopLevelWidgetDestroyed);
 }
 
 void PartManager::removeManagedTopLevelWidget(const QWidget *topLevel)
 {
     d->m_managedTopLevelWidgets.removeAll(topLevel);
 }
 
 void PartManager::slotManagedTopLevelWidgetDestroyed()
 {
     const QWidget *widget = static_cast<const QWidget *>(sender());
     removeManagedTopLevelWidget(widget);
 }
 
 int PartManager::reason() const
 {
     return d->m_reason;
 }
 
 void PartManager::setIgnoreExplictFocusRequests(bool ignore)
 {
     d->m_bIgnoreExplicitFocusRequest = ignore;
 }
 
 #include "moc_partmanager.cpp"