File indexing completed on 2024-04-14 04:36:49

 /*
  * SPDX-FileCopyrightText: (C) 2019 Marco Martin <mart@kde.org>
  * SPDX-FileCopyrightText: (C) 2020 Carl Schwan <carl@carlschwan.eu>
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #include "resizehandle.h"
 #include "resizerectangle.h"
 
 #include <QCursor>
 #include <cmath>
 
 ResizeHandle::ResizeHandle(QQuickItem *parent)
     : QQuickItem(parent)
 {
     setAcceptedMouseButtons(Qt::LeftButton);
 
     auto syncCursor = [this]() {
         switch (m_resizeCorner) {
         case Left:
         case Right:
             setCursor(QCursor(Qt::SizeHorCursor));
             break;
         case Top:
         case Bottom:
             setCursor(QCursor(Qt::SizeVerCursor));
             break;
         case TopLeft:
         case BottomRight:
             setCursor(QCursor(Qt::SizeFDiagCursor));
             break;
         case TopRight:
         case BottomLeft:
         default:
             setCursor(Qt::SizeBDiagCursor);
         }
     };
 
     syncCursor();
     connect(this, &ResizeHandle::resizeCornerChanged, this, syncCursor);
 }
 
 QQuickItem *ResizeHandle::rectangle() const
 {
     return m_rectangle;
 }
 
 void ResizeHandle::setResizeCorner(ResizeHandle::Corner corner)
 {
     if (m_resizeCorner == corner) {
         return;
     }
     m_resizeCorner = corner;
     Q_EMIT resizeCornerChanged();
 }
 
 void ResizeHandle::setRectangle(QQuickItem *rectangle)
 {
     if (m_rectangle == rectangle) {
         return;
     }
     m_rectangle = qobject_cast<ResizeRectangle *>(rectangle);
     Q_EMIT rectangleChanged();
 }
 
 bool ResizeHandle::resizeBlocked() const
 {
     return false; // m_resizeWidthBlocked || m_resizeHeightBlocked;
 }
 
 bool ResizeHandle::resizeLeft() const
 {
     return m_resizeCorner == Left || m_resizeCorner == TopLeft || m_resizeCorner == BottomLeft;
 }
 
 bool ResizeHandle::resizeTop() const
 {
     return m_resizeCorner == Top || m_resizeCorner == TopLeft || m_resizeCorner == TopRight;
 }
 
 bool ResizeHandle::resizeRight() const
 {
     return m_resizeCorner == Right || m_resizeCorner == TopRight || m_resizeCorner == BottomRight;
 }
 
 bool ResizeHandle::resizeBottom() const
 {
     return m_resizeCorner == Bottom || m_resizeCorner == BottomLeft || m_resizeCorner == BottomRight;
 }
 
 void ResizeHandle::setResizeBlocked(bool width, bool height)
 {
     if (m_resizeWidthBlocked == width && m_resizeHeightBlocked == height) {
         return;
     }
 
     m_resizeWidthBlocked = width;
     m_resizeHeightBlocked = height;
 
     Q_EMIT resizeBlockedChanged();
 }
 
 void ResizeHandle::mousePressEvent(QMouseEvent *event)
 {
     m_mouseDownPosition = event->windowPos();
     m_mouseDownGeometry = QRectF(m_rectangle->insideX(), m_rectangle->insideY(), m_rectangle->insideWidth(), m_rectangle->insideHeight());
     setResizeBlocked(false, false);
     event->accept();
 }
 
 void ResizeHandle::mouseMoveEvent(QMouseEvent *event)
 {
     const QPointF difference = m_mouseDownPosition - event->windowPos();
 
     const QSizeF minimumSize = QSize(20, 20);
 
     // Horizontal resize
     if (resizeLeft()) {
         const qreal width = qMax(minimumSize.width(), m_mouseDownGeometry.width() + difference.x());
         const qreal x = m_mouseDownGeometry.x() + (m_mouseDownGeometry.width() - width);
 
         m_rectangle->setInsideX(x);
         m_rectangle->setInsideWidth(width);
         setResizeBlocked(m_mouseDownGeometry.width() + difference.x() < minimumSize.width(), m_resizeHeightBlocked);
     } else if (resizeRight()) {
         const qreal width = qMax(minimumSize.width(), m_mouseDownGeometry.width() - difference.x());
 
         m_rectangle->setInsideWidth(width);
         setResizeBlocked(m_mouseDownGeometry.width() - difference.x() < minimumSize.width(), m_resizeHeightBlocked);
     }
 
     // Vertical Resize
     if (resizeTop()) {
         const qreal height = qMax(minimumSize.height(), m_mouseDownGeometry.height() + difference.y());
         const qreal y = m_mouseDownGeometry.y() + (m_mouseDownGeometry.height() - height);
 
         m_rectangle->setInsideY(y);
         m_rectangle->setInsideHeight(height);
         setResizeBlocked(m_resizeWidthBlocked, m_mouseDownGeometry.height() + difference.y() < minimumSize.height());
     } else if (resizeBottom()) {
         const qreal height = qMax(minimumSize.height(), m_mouseDownGeometry.height() - difference.y());
 
         m_rectangle->setInsideHeight(qMax(height, minimumSize.height()));
         setResizeBlocked(m_resizeWidthBlocked, m_mouseDownGeometry.height() - difference.y() < minimumSize.height());
     }
 
     event->accept();
 }
 
 void ResizeHandle::mouseReleaseEvent(QMouseEvent *event)
 {
     event->accept();
 
     setResizeBlocked(false, false);
     Q_EMIT resizeBlockedChanged();
 }