Differential D22034 Diff 62268 components/containmentlayoutmanager/resizehandle.cpp

Changeset View

Standalone View

View Options

components/containmentlayoutmanager/resizehandle.cpp

  • This file was added.
1​/*
2​ * Copyright 2019 by Marco Martin <mart@kde.org>
3​ *
4​ * This program is free software; you can redistribute it and/or modify
5​ * it under the terms of the GNU Library General Public License as
6​ * published by the Free Software Foundation; either version 2, or
7​ * (at your option) any later version.
8​ *
9​ * This program is distributed in the hope that it will be useful,
10​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12​ * GNU Library General Public License for more details
13​ *
14​ * You should have received a copy of the GNU Library General Public
15​ * License along with this program; if not, write to the
16​ * Free Software Foundation, Inc.,
17​ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18​ *
19​ */
20​
21​#include "resizehandle.h"
22​
23​#include <QCursor>
24​#include <cmath>
25​
26​ResizeHandle::ResizeHandle(QQuickItem *parent)
27​ : QQuickItem(parent)
28​{
29​ setAcceptedMouseButtons(Qt::LeftButton);
30​
31​ QQuickItem *candidate = parent;
32​ while (candidate) {
33​ ConfigOverlay *overlay = qobject_cast<ConfigOverlay *>(candidate);
34​ if (overlay) {
35​ setConfigOverlay(overlay);
36​ break;
37​ }
38​
39​ candidate = candidate->parentItem();
40​ }
41​
42​ connect(this, &QQuickItem::parentChanged, this, [this]() {
43​ QQuickItem *candidate = parentItem();
davidedmundsonUnsubmitted
Not Done

we monitor the direct parent, but ConfigOverlay could be anywhere on the ancestory tree.

davidedmundson: we monitor the direct parent, but ConfigOverlay could be anywhere on the ancestory tree.
martAuthorUnsubmitted
Not Done

This will catch it if the overlay is an ancestor..
what it doesn't support is dynamic parent changes somewhere in the tree higher than direct parent.

monitoring every parent of parents and dynamically rebuilding the connection chain when one of them change, seems a bit.. overkill?
not sure how to do this in another way...

mart: This will catch it if the overlay is an ancestor.. what it doesn't support is dynamic parent…
44​ while (candidate) {
45​ ConfigOverlay *overlay = qobject_cast<ConfigOverlay *>(candidate);
46​ if (overlay) {
47​ setConfigOverlay(overlay);
48​ break;
49​ }
50​
51​ candidate = candidate->parentItem();
52​ }
53​ });
54​
55​ auto syncCursor = [this] () {
56​ switch (m_resizeCorner) {
57​ case Left:
58​ case Right:
59​ setCursor(QCursor(Qt::SizeHorCursor));
60​ break;
61​ case Top:
62​ case Bottom:
63​ setCursor(QCursor(Qt::SizeVerCursor));
64​ break;
65​ case TopLeft:
66​ case BottomRight:
67​ setCursor(QCursor(Qt::SizeFDiagCursor));
68​ break;
69​ case TopRight:
70​ case BottomLeft:
71​ default:
72​ setCursor(Qt::SizeBDiagCursor);
73​ }
74​ };
75​
76​ syncCursor();
77​ connect(this, &ResizeHandle::resizeCornerChanged, this, syncCursor);
78​}
79​
80​ResizeHandle::~ResizeHandle()
81​{
82​}
83​
84​bool ResizeHandle::resizeBlocked() const
85​{
86​ return m_resizeWidthBlocked || m_resizeHeightBlocked;
87​}
88​
89​bool ResizeHandle::resizeLeft() const
90​{
91​ return m_resizeCorner == Left || m_resizeCorner == TopLeft || m_resizeCorner == BottomLeft;
92​}
93​
94​bool ResizeHandle::resizeTop() const
95​{
96​ return m_resizeCorner == Top || m_resizeCorner == TopLeft || m_resizeCorner == TopRight;
97​}
98​
99​bool ResizeHandle::resizeRight() const
100​{
101​ return m_resizeCorner == Right || m_resizeCorner == TopRight ||m_resizeCorner == BottomRight;
102​}
103​
104​bool ResizeHandle::resizeBottom() const
105​{
106​ return m_resizeCorner == Bottom || m_resizeCorner == BottomLeft || m_resizeCorner == BottomRight;
107​}
108​
109​void ResizeHandle::setResizeBlocked(bool width, bool height)
110​{
111​ if (m_resizeWidthBlocked == width && m_resizeHeightBlocked == height) {
112​ return;
113​ }
114​
115​ m_resizeWidthBlocked = width;
116​ m_resizeHeightBlocked = height;
117​
118​ emit resizeBlockedChanged();
119​}
120​
121​
122​void ResizeHandle::mousePressEvent(QMouseEvent *event)
123​{
124​ ItemContainer *itemContainer = m_configOverlay->itemContainer();
125​ if (!itemContainer) {
126​ return;
127​ }
128​ m_mouseDownPosition = event->windowPos();
129​ m_mouseDownGeometry = QRectF(itemContainer->x(), itemContainer->y(), itemContainer->width(), itemContainer->height());
130​ setResizeBlocked(false, false);
131​ event->accept();
132​}
133​
134​void ResizeHandle::mouseMoveEvent(QMouseEvent *event)
135​{
136​ if (!m_configOverlay || !m_configOverlay->itemContainer()) {
137​ return;
138​ }
139​
140​ ItemContainer *itemContainer = m_configOverlay->itemContainer();
141​ AppletsLayout *layout = itemContainer->layout();
142​
143​ if (!layout) {
144​ return;
145​ }
146​
147​ layout->releaseSpace(itemContainer);
148​ const QPointF difference = m_mouseDownPosition - event->windowPos();
149​
150​ QSizeF minimumSize = QSize(layout->minimumItemWidth(), layout->minimumItemHeight());
151​ if (itemContainer->layoutAttached()) {
152​ minimumSize.setWidth(qMax(minimumSize.width(), itemContainer->layoutAttached()->property("minimumWidth").toReal()));
153​ minimumSize.setHeight(qMax(minimumSize.height(), itemContainer->layoutAttached()->property("minimumHeight").toReal()));
154​ }
155​
156​ //Now make minimumSize an integer number of cells
157​ minimumSize.setWidth(ceil(minimumSize.width() / layout->cellWidth()) * layout->cellWidth());
158​ minimumSize.setHeight(ceil(minimumSize.height() / layout->cellWidth()) * layout->cellHeight());
159​
160​ // Horizontal resize
161​ if (resizeLeft()) {
162​ const qreal width = qMax(minimumSize.width(), m_mouseDownGeometry.width() + difference.x());
163​ const qreal x = m_mouseDownGeometry.x() + (m_mouseDownGeometry.width() - width);
164​
165​ // -1 to have a bit of margins around
166​ if (layout->isRectAvailable(x - 1, m_mouseDownGeometry.y(), width, m_mouseDownGeometry.height())) {
167​ itemContainer->setX(x);
168​ itemContainer->setWidth(width);
169​ setResizeBlocked(m_mouseDownGeometry.width() + difference.x() < minimumSize.width(), m_resizeHeightBlocked);
170​ } else {
171​ setResizeBlocked(true, m_resizeHeightBlocked);
172​ }
173​ } else if (resizeRight()) {
174​ const qreal width = qMax(minimumSize.width(), m_mouseDownGeometry.width() - difference.x());
175​
176​ if (layout->isRectAvailable(m_mouseDownGeometry.x(), m_mouseDownGeometry.y(), width, m_mouseDownGeometry.height())) {
177​ itemContainer->setWidth(width);
178​ setResizeBlocked(m_mouseDownGeometry.width() - difference.x() < minimumSize.width(), m_resizeHeightBlocked);
179​ } else {
180​ setResizeBlocked(true, m_resizeHeightBlocked);
181​ }
182​ }
183​
184​ // Vertical Resize
185​ if (resizeTop()) {
186​ const qreal height = qMax(minimumSize.height(), m_mouseDownGeometry.height() + difference.y());
187​ const qreal y = m_mouseDownGeometry.y() + (m_mouseDownGeometry.height() - height);
188​
189​ // -1 to have a bit of margins around
190​ if (layout->isRectAvailable(m_mouseDownGeometry.x(), y - 1, m_mouseDownGeometry.width(), m_mouseDownGeometry.height())) {
191​ itemContainer->setY(y);
192​ itemContainer->setHeight(height);
193​ setResizeBlocked(m_resizeWidthBlocked,
194​ m_mouseDownGeometry.height() + difference.y() < minimumSize.height());
195​ } else {
196​ setResizeBlocked(m_resizeWidthBlocked, true);
197​ }
198​ } else if (resizeBottom()) {
199​ const qreal height = qMax(minimumSize.height(), m_mouseDownGeometry.height() - difference.y());
200​
201​ if (layout->isRectAvailable(m_mouseDownGeometry.x(), m_mouseDownGeometry.y(), m_mouseDownGeometry.width(), height)) {
202​ itemContainer->setHeight(qMax(height, minimumSize.height()));
203​ setResizeBlocked(m_resizeWidthBlocked,
204​ m_mouseDownGeometry.height() - difference.y() < minimumSize.height());
205​ } else {
206​ setResizeBlocked(m_resizeWidthBlocked, true);
207​ }
208​ }
209​
210​ event->accept();
211​}
212​
213​void ResizeHandle::mouseReleaseEvent(QMouseEvent *event)
214​{
215​ if (!m_configOverlay || !m_configOverlay->itemContainer()) {
216​ return;
217​ }
218​
219​ ItemContainer *itemContainer = m_configOverlay->itemContainer();
220​ AppletsLayout *layout = itemContainer->layout();
221​
222​ if (!layout) {
223​ return;
224​ }
225​
226​ layout->positionItem(itemContainer);
227​
228​ event->accept();
229​
230​ setResizeBlocked(false, false);
231​ emit resizeBlockedChanged();
232​}
233​
234​void ResizeHandle::setConfigOverlay(ConfigOverlay *handle)
235​{
236​ if (handle == m_configOverlay) {
237​ return;
238​ }
239​
240​ m_configOverlay = handle;
241​}
242​
243​#include "moc_resizehandle.cpp"