File indexing completed on 2024-04-28 04:32:23

 /*
  * SPDX-FileCopyrightText: 2009 Aurélien Gâteau <agateau@kde.org>
  * SPDX-FileCopyrightText: 2009 Kåre Sårs <kare.sars@iki.fi>
  * SPDX-FileCopyrightText: 2014 Gregor Mitsch : port to KDE5 frameworks
  *
  * SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
  */
 
 #include "splittercollapser.h"
 
 #include <QApplication>
 #include <QEvent>
 #include <QMouseEvent>
 #include <QSplitter>
 #include <QStyleOptionToolButton>
 #include <QStylePainter>
 #include <QTimeLine>
 
 namespace KSaneIface
 {
 
 enum Direction {
     LTR      = 1 << 0,
     RTL      = 1 << 1,
     Vertical = 1 << 2,
     TTB      = Vertical + (1 << 0),
     BTT      = Vertical + (1 << 1)
 };
 
 const int TIMELINE_DURATION = 500;
 
 const qreal MINIMUM_OPACITY = 0.3;
 
 struct ArrowTypes {
     ArrowTypes()
         : visible(Qt::NoArrow), notVisible(Qt::NoArrow) {}
 
     ArrowTypes(Qt::ArrowType t1, Qt::ArrowType t2)
         : visible(t1), notVisible(t2) {}
 
     Qt::ArrowType visible,
     notVisible;
 
     Qt::ArrowType get(bool isVisible)
     {
         return isVisible ? visible : notVisible;
     }
 };
 
 struct SplitterCollapserPrivate {
     SplitterCollapser *q;
     QSplitter *mSplitter;
     QWidget *mWidget;
     Direction mDirection;
     QTimeLine *mOpacityTimeLine;
     int mSizeAtCollaps;
 
     bool isVertical() const
     {
         return mDirection & Vertical;
     }
 
     bool isVisible() const
     {
         bool isVisible = mWidget->isVisible();
         QRect widgetRect = mWidget->geometry();
         if (isVisible) {
             QPoint br = widgetRect.bottomRight();
             if ((br.x() <= 0) || (br.y() <= 0)) {
                 isVisible = false;
             }
         }
         return isVisible;
     }
 
     void updatePosition()
     {
         int x, y;
         QRect widgetRect = mWidget->geometry();
         int splitterWidth = mSplitter->width();
         int handleWidth = mSplitter->handleWidth();
         int width = q->width();
 
         if (!isVertical()) {
             // FIXME: Make this configurable
             y = 30;
             if (mDirection == LTR) {
                 if (isVisible()) {
                     x = widgetRect.right() + handleWidth;
                 } else {
                     x = 0;
                 }
             } else { // RTL
                 if (isVisible()) {
                     x = widgetRect.left() - handleWidth - width;
                 } else {
                     x = splitterWidth - handleWidth - width;
                 }
             }
         } else {
             // FIXME
             x = 0;
             y = 0;
         }
         q->move(x, y);
     }
 
     void updateArrow()
     {
         static QMap<Direction, ArrowTypes> arrowForDirection;
         if (arrowForDirection.isEmpty()) {
             arrowForDirection[LTR] = ArrowTypes(Qt::LeftArrow,  Qt::RightArrow);
             arrowForDirection[RTL] = ArrowTypes(Qt::RightArrow, Qt::LeftArrow);
             arrowForDirection[TTB] = ArrowTypes(Qt::UpArrow,    Qt::DownArrow);
             arrowForDirection[BTT] = ArrowTypes(Qt::DownArrow,  Qt::UpArrow);
         }
         q->setArrowType(arrowForDirection[mDirection].get(isVisible()));
     }
 
     void widgetEventFilter(QEvent *event)
     {
         switch (event->type()) {
         case QEvent::Resize:
             updatePosition();
             updateOpacity();
             break;
 
         case QEvent::Move:
         case QEvent::Show:
         case QEvent::Hide:
             updatePosition();
             updateOpacity();
             updateArrow();
             break;
 
         default:
             break;
         }
     }
 
     void updateOpacity()
     {
         QPoint pos = q->parentWidget()->mapFromGlobal(QCursor::pos());
         QRect opaqueRect = q->geometry();
         bool opaqueCollapser = opaqueRect.contains(pos);
         int frame = mOpacityTimeLine->currentFrame();
         if (opaqueCollapser && frame == mOpacityTimeLine->startFrame()) {
             mOpacityTimeLine->setDirection(QTimeLine::Forward);
             startTimeLine();
         } else if (!opaqueCollapser && frame == mOpacityTimeLine->endFrame()) {
             mOpacityTimeLine->setDirection(QTimeLine::Backward);
             startTimeLine();
         }
     }
 
     void startTimeLine()
     {
         if (mOpacityTimeLine->state() != QTimeLine::Running) {
             mOpacityTimeLine->start();
         }
     }
 };
 
 SplitterCollapser::SplitterCollapser(QSplitter *splitter, QWidget *widget)
     : QToolButton(),
       d(new SplitterCollapserPrivate)
 {
     d->q = this;
 
     // We do not want our collapser to be added as a regular widget in the
     // splitter!
     setAttribute(Qt::WA_NoChildEventsForParent);
 
     d->mOpacityTimeLine = new QTimeLine(TIMELINE_DURATION, this);
     d->mOpacityTimeLine->setFrameRange(int(MINIMUM_OPACITY * 1000), 1000);
     connect(d->mOpacityTimeLine, SIGNAL(valueChanged(qreal)), SLOT(update()));
 
     d->mWidget = widget;
     d->mWidget->installEventFilter(this);
 
     qApp->installEventFilter(this);
 
     d->mSplitter = splitter;
     setParent(d->mSplitter);
 
     if (splitter->indexOf(widget) < splitter->count() / 2) {
         d->mDirection = LTR;
     } else {
         d->mDirection = RTL;
     }
     if (splitter->orientation() == Qt::Vertical) {
         // FIXME: Ugly!
         d->mDirection = static_cast<Direction>(int(d->mDirection) + int(TTB));
     }
 
     connect(this, SIGNAL(clicked()), SLOT(slotClicked()));
 
     show();
 }
 
 SplitterCollapser::~SplitterCollapser()
 {
     delete d;
 }
 
 bool SplitterCollapser::eventFilter(QObject *object, QEvent *event)
 {
     if (object == d->mWidget) {
         d->widgetEventFilter(event);
     } else { /* app */
         if (event->type() == QEvent::MouseMove) {
             d->updateOpacity();
         }
     }
     return false;
 }
 
 QSize SplitterCollapser::sizeHint() const
 {
     int extent = style()->pixelMetric(QStyle::PM_ScrollBarExtent);
     QSize sh(extent * 3 / 4, extent * 240 / 100);
     if (d->isVertical()) {
         sh.transpose();
     }
     return sh;
 }
 
 void SplitterCollapser::slotClicked()
 {
     QList<int> sizes = d->mSplitter->sizes();
     int index = d->mSplitter->indexOf(d->mWidget);
     if (d->isVisible()) {
         d->mSizeAtCollaps = sizes[index];
         sizes[index] = 0;
     } else {
         if (d->mSizeAtCollaps != 0) {
             sizes[index] = d->mSizeAtCollaps;
         } else {
             if (d->isVertical()) {
                 sizes[index] = d->mWidget->sizeHint().height();
             } else {
                 sizes[index] = d->mWidget->sizeHint().width();
             }
         }
     }
     d->mSplitter->setSizes(sizes);
 }
 
 void SplitterCollapser::slotCollapse()
 {
     if (d->isVisible()) {
         slotClicked();
     }
     // else do nothing
 }
 
 void SplitterCollapser::slotRestore()
 {
     if (!d->isVisible()) {
         slotClicked();
     }
     // else do nothing
 }
 
 void SplitterCollapser::slotSetCollapsed(bool collapse)
 {
     if (collapse == d->isVisible()) {
         slotClicked();
     }
     // else do nothing
 }
 
 void SplitterCollapser::paintEvent(QPaintEvent *)
 {
     QStylePainter painter(this);
     qreal opacity = d->mOpacityTimeLine->currentFrame() / 1000.;
     painter.setOpacity(opacity);
 
     QStyleOptionToolButton opt;
     initStyleOption(&opt);
     if (d->mDirection == LTR) {
         opt.rect.setLeft(-width());
     } else {
         opt.rect.setWidth(width() * 2);
     }
     painter.drawPrimitive(QStyle::PE_PanelButtonTool, opt);
 
     QStyleOptionToolButton opt2;
     initStyleOption(&opt2);
     painter.drawControl(QStyle::CE_ToolButtonLabel, opt2);
 }
 
 } // namespace
 
 #include "moc_splittercollapser.cpp"