File indexing completed on 2024-05-12 16:58:29

 /*
  * SPDX-FileCopyrightText: 2014 Hugo Pereira Da Costa <hugo.pereira@free.fr>
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "breezesplitterproxy.h"
 
 #include "breezestyleconfigdata.h"
 
 #include <QCoreApplication>
 #include <QDebug>
 #include <QPainter>
 
 // Q_FALLTHROUGH() for Qt < 5.8
 #ifndef Q_FALLTHROUGH
 #if defined(__has_cpp_attribute)
 #if __has_cpp_attribute(fallthrough)
 #define Q_FALLTHROUGH() [[fallthrough]]
 #elif __has_cpp_attribute(clang::fallthrough)
 #define Q_FALLTHROUGH() [[clang::fallthrough]]
 #elif __has_cpp_attribute(gnu::fallthrough)
 #define Q_FALLTHROUGH() [[gnu::fallthrough]]
 #endif
 #endif
 #ifndef Q_FALLTHROUGH
 #if __GNUC__ >= 7
 #define Q_FALLTHROUGH() __attribute__((fallthrough))
 #elif (__clang_major__ > 3) || (__clang_major__ == 3 && __clang_minor__ >= 5)
 #define Q_FALLTHROUGH() [[clang::fallthrough]]
 #else
 #define Q_FALLTHROUGH()
 #endif
 #endif
 #endif
 
 namespace Breeze
 {
 //____________________________________________________________________
 void SplitterFactory::setEnabled(bool value)
 {
     if (_enabled != value) {
         // store
         _enabled = value;
 
         // assign to existing splitters
         for (WidgetMap::iterator iter = _widgets.begin(); iter != _widgets.end(); ++iter) {
             if (iter.value()) {
                 iter.value().data()->setEnabled(value);
             }
         }
     }
 }
 
 //____________________________________________________________________
 bool SplitterFactory::registerWidget(QWidget *widget)
 {
     // check widget type
     if (qobject_cast<QMainWindow *>(widget)) {
         WidgetMap::iterator iter(_widgets.find(widget));
         if (iter == _widgets.end() || !iter.value()) {
             widget->installEventFilter(&_addEventFilter);
             SplitterProxy *proxy(new SplitterProxy(widget, _enabled));
             widget->removeEventFilter(&_addEventFilter);
 
             widget->installEventFilter(proxy);
             _widgets.insert(widget, proxy);
 
         } else {
             widget->removeEventFilter(iter.value().data());
             widget->installEventFilter(iter.value().data());
         }
 
         return true;
 
     } else if (qobject_cast<QSplitterHandle *>(widget)) {
         QWidget *window(widget->window());
         WidgetMap::iterator iter(_widgets.find(window));
         if (iter == _widgets.end() || !iter.value()) {
             window->installEventFilter(&_addEventFilter);
             SplitterProxy *proxy(new SplitterProxy(window, _enabled));
             window->removeEventFilter(&_addEventFilter);
 
             widget->installEventFilter(proxy);
             _widgets.insert(window, proxy);
 
         } else {
             widget->removeEventFilter(iter.value().data());
             widget->installEventFilter(iter.value().data());
         }
 
         return true;
 
     } else {
         return false;
     }
 }
 
 //____________________________________________________________________
 void SplitterFactory::unregisterWidget(QWidget *widget)
 {
     WidgetMap::iterator iter(_widgets.find(widget));
     if (iter != _widgets.end()) {
         if (iter.value()) {
             iter.value().data()->deleteLater();
         }
         _widgets.erase(iter);
     }
 }
 
 //____________________________________________________________________
 SplitterProxy::SplitterProxy(QWidget *parent, bool enabled)
     : QWidget(parent)
     , _enabled(enabled)
     , _timerId(0)
 {
     setAttribute(Qt::WA_TranslucentBackground, true);
     setAttribute(Qt::WA_OpaquePaintEvent, false);
     hide();
 }
 
 //____________________________________________________________________
 void SplitterProxy::setEnabled(bool value)
 {
     // make sure status has changed
     if (_enabled != value) {
         _enabled = value;
         if (!_enabled) {
             clearSplitter();
         }
     }
 }
 
 //____________________________________________________________________
 bool SplitterProxy::eventFilter(QObject *object, QEvent *event)
 {
     // do nothing if disabled
     if (!_enabled) {
         return false;
     }
 
     // do nothing in case of mouse grab
     if (mouseGrabber()) {
         return false;
     }
 
     switch (event->type()) {
     case QEvent::HoverEnter:
         if (!isVisible()) {
             // cast to splitter handle
             if (QSplitterHandle *handle = qobject_cast<QSplitterHandle *>(object)) {
                 setSplitter(handle);
             }
         }
 
         return false;
 
     case QEvent::HoverMove:
     case QEvent::HoverLeave:
         return isVisible() && object == _splitter.data();
 
     case QEvent::MouseMove:
     case QEvent::Timer:
     case QEvent::Move:
         return false;
 
     case QEvent::CursorChange:
         if (QWidget *window = qobject_cast<QMainWindow *>(object)) {
             if (window->cursor().shape() == Qt::SplitHCursor || window->cursor().shape() == Qt::SplitVCursor) {
                 setSplitter(window);
             }
         }
         return false;
 
     case QEvent::WindowDeactivate:
     case QEvent::MouseButtonRelease:
         clearSplitter();
         return false;
 
     default:
         return false;
     }
 }
 
 //____________________________________________________________________
 bool SplitterProxy::event(QEvent *event)
 {
     switch (event->type()) {
 #if 0
     case QEvent::Paint:
     {
         QPainter painter( this );
         painter.setClipRegion( static_cast<QPaintEvent*>( event )->region() );
         painter.setRenderHints( QPainter::Antialiasing );
         painter.setPen( Qt::red );
         painter.drawRect( QRectF( rect() ).adjusted( 0.5, 0.5, -0.5, -0.5 ) );
         return true;
     }
 #endif
 
     case QEvent::MouseMove:
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonRelease: {
         // check splitter
         if (!_splitter) {
             return false;
         }
 
         event->accept();
 
         // grab on mouse press
         if (event->type() == QEvent::MouseButtonPress) {
             grabMouse();
             resize(1, 1);
         }
 
         // cast to mouse event
         QMouseEvent *mouseEvent(static_cast<QMouseEvent *>(event));
 
         // get relevant position to post mouse drag event to application
         if (event->type() == QEvent::MouseButtonPress) {
             // use hook, to make sure splitter is properly dragged
             QMouseEvent copy(mouseEvent->type(), _hook, mouseEvent->button(), mouseEvent->buttons(), mouseEvent->modifiers());
 
             QCoreApplication::sendEvent(_splitter.data(), &copy);
 
         } else {
             // map event position to current splitter and post.
             QMouseEvent copy(mouseEvent->type(),
                              _splitter.data()->mapFromGlobal(mouseEvent->globalPos()),
                              mouseEvent->button(),
                              mouseEvent->buttons(),
                              mouseEvent->modifiers());
 
             QCoreApplication::sendEvent(_splitter.data(), &copy);
         }
 
         // release grab on mouse-Release
         if (event->type() == QEvent::MouseButtonRelease && mouseGrabber() == this) {
             releaseMouse();
         }
 
         return true;
     }
 
     case QEvent::Timer:
         if (static_cast<QTimerEvent *>(event)->timerId() != _timerId) {
             return QWidget::event(event);
         }
 
         /*
         Fall through is intended.
         We somehow lost a QEvent::Leave before timeout. We fix it from here
         */
 
         Q_FALLTHROUGH();
 
     case QEvent::HoverLeave:
     case QEvent::Leave: {
         if (mouseGrabber() == this) {
             return true;
         }
 
         // reset splitter
         if (isVisible() && !rect().contains(mapFromGlobal(QCursor::pos()))) {
             clearSplitter();
         }
         return true;
     }
 
     default:
         return QWidget::event(event);
     }
 }
 
 //____________________________________________________________________
 void SplitterProxy::setSplitter(QWidget *widget)
 {
     // check if changed
     if (_splitter.data() == widget) {
         return;
     }
 
     // get cursor position
     const QPoint position(QCursor::pos());
 
     // store splitter and hook
     _splitter = widget;
     _hook = _splitter.data()->mapFromGlobal(position);
 
     // adjust rect
     QRect rect(0, 0, 2 * StyleConfigData::splitterProxyWidth(), 2 * StyleConfigData::splitterProxyWidth());
     rect.moveCenter(parentWidget()->mapFromGlobal(position));
     setGeometry(rect);
     setCursor(_splitter.data()->cursor().shape());
 
     // show
     raise();
     show();
 
     // timer used to automatically hide proxy in case leave events are lost
     if (!_timerId) {
         _timerId = startTimer(150);
     }
 }
 
 //____________________________________________________________________
 void SplitterProxy::clearSplitter()
 {
     // check if changed
     if (!_splitter) {
         return;
     }
 
     // release mouse
     if (mouseGrabber() == this) {
         releaseMouse();
     }
 
     // send hover event
     if (_splitter) {
         // SplitterProxy intercepts HoverLeave/HoverMove events to _splitter,
         // but this is meant to reach it directly. Unset _splitter to stop interception.
         auto splitter = _splitter;
         _splitter.clear();
         QHoverEvent hoverEvent(qobject_cast<QSplitterHandle *>(splitter.data()) ? QEvent::HoverLeave : QEvent::HoverMove,
                                splitter.data()->mapFromGlobal(QCursor::pos()),
                                _hook);
         QCoreApplication::sendEvent(splitter.data(), &hoverEvent);
     }
 
     // kill timer if any
     if (_timerId) {
         killTimer(_timerId);
         _timerId = 0;
     }
 
     // hide
     parentWidget()->setUpdatesEnabled(false);
     // Note: This sends a synthetic mouse event to the widget below (to get focus), which might be
     // another SplitterHandle, therefore enabling this SplitterProxy again!
     hide();
     parentWidget()->setUpdatesEnabled(true);
 }
 
 }