Differential D22034 Diff 61786 components/containmentlayoutmanager/gridlayoutmanager.cpp

Changeset View

Standalone View

View Options

components/containmentlayoutmanager/gridlayoutmanager.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 "gridlayoutmanager.h"
22​#include "appletslayout.h"
23​#include <cmath>
24​
25​GridLayoutManager::GridLayoutManager(AppletsLayout *layout)
26​ : AbstractLayoutManager(layout)
27​{
28​}
29​
30​GridLayoutManager::~GridLayoutManager()
31​{
32​}
33​
34​QString GridLayoutManager::serializeLayout() const
35​{
36​ QString result;
37​
38​ for (auto *item : layout()->childItems()) {
39​ ItemContainer *itemCont = qobject_cast<ItemContainer*>(item);
40​ if (itemCont && itemCont != layout()->placeHolder()) {
41​ result += itemCont->key() + QLatin1Char(':')
42​ + QString::number(itemCont->x()) + QLatin1Char(',')
43​ + QString::number(itemCont->y()) + QLatin1Char(',')
44​ + QString::number(itemCont->width()) + QLatin1Char(',')
45​ + QString::number(itemCont->height()) + QLatin1Char(',')
46​ + QString::number(itemCont->rotation()) + QLatin1Char(';');
47​ }
48​ }
49​
50​ return result;
51​}
52​
53​void GridLayoutManager::parseLayout(const QString &savedLayout)
54​{
55​ m_parsedConfig.clear();
56​ QStringList itemsConfigs = savedLayout.split(QLatin1Char(';'));
57​
58​ for (const auto &itemString : itemsConfigs) {
59​ QStringList itemConfig = itemString.split(QLatin1Char(':'));
60​ if (itemConfig.count() != 2) {
61​ continue;
62​ }
63​
64​ QString id = itemConfig[0];
65​ QStringList itemGeom = itemConfig[1].split(QLatin1Char(','));
66​ if (itemGeom.count() != 5) {
67​ continue;
68​ }
69​
70​ m_parsedConfig[id] = {itemGeom[0].toInt(), itemGeom[1].toInt(), itemGeom[2].toInt(), itemGeom[3].toInt(), itemGeom[4].toInt()};
71​ }
72​}
73​
74​bool GridLayoutManager::itemIsManaged(ItemContainer *item)
75​{
76​ return m_pointsForItem.contains(item);
77​}
78​
79​inline void maintainItemEdgeAlignment(QQuickItem *item, const QRectF &newRect, const QRectF &oldRect)
80​{
81​ const qreal leftDist = item->x() - oldRect.x();
82​ const qreal hCenterDist = item->x() + item->width()/2 - oldRect.center().x();
83​ const qreal rightDist = oldRect.right() - item->x() - item->width();
84​
85​ qreal hMin = qMin(qMin(qAbs(leftDist), qAbs(hCenterDist)), qAbs(rightDist));
86​ if (qFuzzyCompare(hMin, qAbs(leftDist))) {
87​ // Right alignment, do nothing
88​ } else if (qFuzzyCompare(hMin, qAbs(hCenterDist))) {
89​ item->setX(newRect.center().x() - item->width()/2 + hCenterDist);
90​ } else if (qFuzzyCompare(hMin, qAbs(rightDist))) {
91​ item->setX(newRect.right() - item->width() - rightDist );
92​ }
93​
94​ const qreal topDist = item->y() - oldRect.y();
95​ const qreal vCenterDist = item->y() + item->height()/2 - oldRect.center().y();
96​ const qreal bottomDist = oldRect.bottom() - item->y() - item->height();
97​
98​ qreal vMin = qMin(qMin(qAbs(topDist), qAbs(vCenterDist)), qAbs(bottomDist));
99​
100​ if (qFuzzyCompare(vMin, qAbs(topDist))) {
101​ // Top alignment, do nothing
102​ } else if (qFuzzyCompare(vMin, qAbs(vCenterDist))) {
103​ item->setY(newRect.center().y() - item->height()/2 + vCenterDist);
104​ } else if (qFuzzyCompare(vMin, qAbs(bottomDist))) {
105​ item->setY(newRect.bottom() - item->height() - bottomDist );
106​ }
107​}
108​
109​void GridLayoutManager::layoutGeometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
110​{
111​ for (auto *item : layout()->childItems()) {
112​ // Stash the old config
113​ //m_parsedConfig[item->key()] = {item->x(), item->y(), item->width(), item->height(), item->rotation()};
114​ // Move the item to maintain the distance with the anchors point
115​ maintainItemEdgeAlignment(item, newGeometry, oldGeometry);
116​ }
117​}
118​
119​void GridLayoutManager::resetLayout()
120​{
121​ m_grid.clear();
122​ m_pointsForItem.clear();
123​ for (auto *item : layout()->childItems()) {
124​ ItemContainer *itemCont = qobject_cast<ItemContainer*>(item);
125​ if (itemCont && itemCont != layout()->placeHolder()) {
126​ // NOTE: do not use positionItemAndAssign here, because we do not want to emit layoutNeedsSaving, to not save after resize
127​ positionItem(itemCont);
128​ assignSpaceImpl(itemCont);
129​ }
130​ }
131​}
132​
133​void GridLayoutManager::resetLayoutFromConfig()
134​{
135​ m_grid.clear();
136​ m_pointsForItem.clear();
137​ QList<ItemContainer *> missingItems;
138​
139​ for (auto *item : layout()->childItems()) {
140​ ItemContainer *itemCont = qobject_cast<ItemContainer*>(item);
141​ if (itemCont && itemCont != layout()->placeHolder()) {
142​ if (!restoreItem(itemCont)) {
143​ missingItems << itemCont;
144​ }
145​ }
146​ }
147​
148​ for (auto *item : missingItems) {
149​ // NOTE: do not use positionItemAndAssign here, because we do not want to emit layoutNeedsSaving, to not save after resize
150​ positionItem(item);
151​ assignSpaceImpl(item);
152​ }
153​}
154​
155​bool GridLayoutManager::restoreItem(ItemContainer *item)
156​{
157​ auto it = m_parsedConfig.find(item->key());
158​
159​ if (it != m_parsedConfig.end()) {
160​ // Actual restore
161​ item->setX(it.value().x);
162​ item->setY(it.value().y);
163​ item->setWidth(it.value().width);
164​ item->setHeight(it.value().height);
165​ item->setRotation(it.value().rotation);
166​
167​ // NOTE: do not use positionItemAndAssign here, because we do not want to emit layoutNeedsSaving, to not save after resize
168​ releaseSpaceImpl(item);
169​ positionItem(item);
170​ assignSpaceImpl(item);
171​
172​ return true;
173​ }
174​
175​ return false;
176​}
177​
178​bool GridLayoutManager::isRectAvailable(const QRectF &rect)
179​{
180​ //TODO: define directions in which it can grow
181​ if (rect.x() < 0 || rect.y() < 0 || rect.x() + rect.width() > layout()->width() || rect.y() + rect.height() > layout()->height()) {
182​ return false;
183​ }
184​
185​ const QRect cellItemGeom = cellBasedGeometry(rect);
186​
187​ for (int row = cellItemGeom.top(); row <= cellItemGeom.bottom(); ++row) {
188​ for (int column = cellItemGeom.left(); column <= cellItemGeom.right(); ++column) {
189​ if (!isCellAvailable(QPair<int, int>(row, column))) {
190​ return false;
191​ }
192​ }
193​ }
194​ return true;
195​}
196​
197​bool GridLayoutManager::assignSpaceImpl(ItemContainer *item)
198​{
199​ // Don't emit extra layoutneedssaving signals
200​ releaseSpaceImpl(item);
201​ if (!isRectAvailable(itemGeometry(item))) {
202​ qWarning()<<"Trying to take space not available"<<item;
203​ return false;
204​ }
205​
206​ const QRect cellItemGeom = cellBasedGeometry(itemGeometry(item));
207​
208​ for (int row = cellItemGeom.top(); row <= cellItemGeom.bottom(); ++row) {
209​ for (int column = cellItemGeom.left(); column <= cellItemGeom.right(); ++column) {
210​ QPair<int, int> cell(row, column);
211​ m_grid.insert(cell, item);
212​ m_pointsForItem[item].insert(cell);
213​ }
214​ }
215​
216​ // Reorder items tab order
217​ for (auto *i2 : layout()->childItems()) {
218​ ItemContainer *item2 = qobject_cast<ItemContainer*>(i2);
219​ if (item2 && item != item2 && item2 != layout()->placeHolder()
220​ && item->y() < item2->y() + item2->height()
221​ && item->x() <= item2->x()) {
222​ item->stackBefore(item2);
223​ break;
224​ }
225​ }
226​
227​ return true;
228​}
229​
230​void GridLayoutManager::releaseSpaceImpl(ItemContainer *item)
231​{
232​ auto it = m_pointsForItem.find(item);
233​
234​ if (it == m_pointsForItem.end()) {
235​ return;
236​ }
237​
238​ for (const auto &point : it.value()) {
239​ m_grid.remove(point);
240​ }
241​
242​ m_pointsForItem.erase(it);
243​}
244​
245​int GridLayoutManager::rows() const
246​{
247​ return layout()->height() / cellSize().height();
248​}
249​
250​int GridLayoutManager::columns() const
251​{
252​ return layout()->width() / cellSize().width();
253​}
254​
255​QRect GridLayoutManager::cellBasedGeometry(const QRectF &geom) const
256​{
257​ return QRect(
258​ round(qBound(0.0, geom.x(), layout()->width() - geom.width()) / cellSize().width()),
259​ round(qBound(0.0, geom.y(), layout()->height() - geom.height()) / cellSize().height()),
260​ round((qreal)geom.width() / cellSize().width()),
261​ round((qreal)geom.height() / cellSize().height())
262​ );
263​}
264​
265​QRect GridLayoutManager::cellBasedBoundingGeometry(const QRectF &geom) const
266​{
267​ return QRect(
268​ floor(qBound(0.0, geom.x(), layout()->width() - geom.width()) / cellSize().width()),
269​ floor(qBound(0.0, geom.y(), layout()->height() - geom.height()) / cellSize().height()),
270​ ceil((qreal)geom.width() / cellSize().width()),
271​ ceil((qreal)geom.height() / cellSize().height())
272​ );
273​}
274​
275​bool GridLayoutManager::isOutOfBounds(const QPair<int, int> &cell) const
276​{
277​ return cell.first < 0
278​ || cell.second < 0
279​ || cell.first >= rows()
280​ || cell.second >= columns();
281​}
282​
283​bool GridLayoutManager::isCellAvailable(const QPair<int, int> &cell) const
284​{
285​ return !isOutOfBounds(cell) && !m_grid.contains(cell);
286​}
287​
288​QRectF GridLayoutManager::itemGeometry(QQuickItem *item) const
289​{
290​ return QRectF(item->x(), item->y(), item->width(), item->height());
291​}
292​
293​QPair<int, int> GridLayoutManager::nextCell(const QPair<int, int> &cell, AppletsLayout::PreferredLayoutDirection direction) const
294​{
295​ QPair<int, int> nCell = cell;
296​
297​ switch (direction) {
298​ case AppletsLayout::AppletsLayout::BottomToTop:
299​ --nCell.first;
300​ break;
301​ case AppletsLayout::AppletsLayout::TopToBottom:
302​ ++nCell.first;
303​ break;
304​ case AppletsLayout::AppletsLayout::RightToLeft:
305​ --nCell.second;
306​ break;
307​ case AppletsLayout::AppletsLayout::LeftToRight:
308​ default:
309​ ++nCell.second;
310​ break;
311​ }
312​
313​ return nCell;
314​}
315​
316​QPair<int, int> GridLayoutManager::nextAvailableCell(const QPair<int, int> &cell, AppletsLayout::PreferredLayoutDirection direction) const
317​{
318​ QPair<int, int> nCell = cell;
319​ while (!isOutOfBounds(nCell)) {
320​ nCell = nextCell(nCell, direction);
321​
322​ if (isOutOfBounds(nCell)) {
323​ switch (direction) {
324​ case AppletsLayout::AppletsLayout::BottomToTop:
325​ nCell.first = rows() - 1;
326​ --nCell.second;
327​ break;
328​ case AppletsLayout::AppletsLayout::TopToBottom:
329​ nCell.first = 0;
330​ ++nCell.second;
331​ break;
332​ case AppletsLayout::AppletsLayout::RightToLeft:
333​ --nCell.first;
334​ nCell.second = columns() - 1;
335​ break;
336​ case AppletsLayout::AppletsLayout::LeftToRight:
337​ default:
338​ ++nCell.first;
339​ nCell.second = 0;
340​ break;
341​ }
342​ }
343​
344​ if (isCellAvailable(nCell)) {
345​ return nCell;
346​ }
347​ }
348​
349​ return QPair<int, int>(-1, -1);
350​}
351​
352​int GridLayoutManager::freeSpaceInDirection(const QPair<int, int> &cell, AppletsLayout::PreferredLayoutDirection direction) const
353​{
354​ QPair<int, int> nCell = cell;
355​
356​ int avail = 0;
357​
358​ while (isCellAvailable(nCell)) {
359​ ++avail;
360​ nCell = nextCell(nCell, direction);
361​ }
362​
363​ return avail;
364​}
365​
366​QRectF GridLayoutManager::nextAvailableSpace(ItemContainer *item, const QSizeF &minimumSize, AppletsLayout::PreferredLayoutDirection direction) const
367​{
368​ // The mionimum size in grid units
369​ const QSize minimumGridSize(
370​ ceil((qreal)minimumSize.width() / cellSize().width()),
371​ ceil((qreal)minimumSize.height() / cellSize().height())
372​ );
373​
374​ QRect itemCellGeom = cellBasedGeometry(itemGeometry(item));
375​ itemCellGeom.setWidth(qMax(itemCellGeom.width(), minimumGridSize.width()));
376​ itemCellGeom.setHeight(qMax(itemCellGeom.height(), minimumGridSize.height()));
377​
378​ QSize partialSize;
379​
380​ QPair<int, int> cell(itemCellGeom.y(), itemCellGeom.x());
381​ if (direction == AppletsLayout::AppletsLayout::RightToLeft) {
382​ cell.second += itemCellGeom.width();
383​ } else if (direction == AppletsLayout::AppletsLayout::BottomToTop) {
384​ cell.first += itemCellGeom.height();
385​ }
386​
387​ while (!isOutOfBounds(cell)) {
388​
389​ if (!isCellAvailable(cell)) {
390​ cell = nextAvailableCell(cell, direction);
391​ }
392​
393​ if (direction == AppletsLayout::LeftToRight || direction == AppletsLayout::RightToLeft) {
394​ partialSize = QSize(INT_MAX, 0);
395​
396​ int currentRow = cell.first;
397​ for (; currentRow < cell.first + itemCellGeom.height(); ++currentRow) {
398​
399​ const int freeRow = freeSpaceInDirection(QPair<int, int>(currentRow, cell.second), direction);
400​
401​ partialSize.setWidth(qMin(partialSize.width(), freeRow));
402​
403​ if (freeRow > 0) {
404​ partialSize.setHeight(partialSize.height() + 1);
405​ } else if (partialSize.height() < minimumGridSize.height()) {
406​ break;
407​ }
408​
409​ if (partialSize.width() >= itemCellGeom.width()
410​ && partialSize.height() >= itemCellGeom.height()) {
411​ break;
412​ } else if (partialSize.width() < minimumGridSize.width()) {
413​ break;
414​ }
415​ }
416​
417​ if (partialSize.width() >= minimumGridSize.width()
418​ && partialSize.height() >= minimumGridSize.height()) {
419​
420​ const int width = qMin(itemCellGeom.width(), partialSize.width()) * cellSize().width();
421​ const int height = qMin(itemCellGeom.height(), partialSize.height()) * cellSize().height();
422​
423​ if (direction == AppletsLayout::RightToLeft) {
424​ return QRectF((cell.second + 1) * cellSize().width() - width,
425​ cell.first * cellSize().height(),
426​ width, height);
427​ // AppletsLayout::LeftToRight
428​ } else {
429​ return QRectF(cell.second * cellSize().width(),
430​ cell.first * cellSize().height(),
431​ width, height);
432​ }
433​ } else {
434​ cell.first = currentRow + 1;
435​ }
436​
437​ } else if (direction == AppletsLayout::TopToBottom || direction == AppletsLayout::BottomToTop) {
438​ partialSize = QSize(0, INT_MAX);
439​
440​ int currentColumn = cell.second;
441​ for (; currentColumn < cell.second + itemCellGeom.width(); ++currentColumn) {
442​
443​ const int freeColumn = freeSpaceInDirection(QPair<int, int>(cell.first, currentColumn), direction);
444​
445​ partialSize.setHeight(qMin(partialSize.height(), freeColumn));
446​
447​ if (freeColumn > 0) {
448​ partialSize.setWidth(partialSize.width() + 1);
449​ } else if (partialSize.width() < minimumGridSize.width()) {
450​ break;
451​ }
452​
453​ if (partialSize.width() >= itemCellGeom.width()
454​ && partialSize.height() >= itemCellGeom.height()) {
455​ break;
456​ } else if (partialSize.height() < minimumGridSize.height()) {
457​ break;
458​ }
459​ }
460​
461​ if (partialSize.width() >= minimumGridSize.width()
462​ && partialSize.height() >= minimumGridSize.height()) {
463​
464​ const int width = qMin(itemCellGeom.width(), partialSize.width()) * cellSize().width();
465​ const int height = qMin(itemCellGeom.height(), partialSize.height()) * cellSize().height();
466​
467​ if (direction == AppletsLayout::BottomToTop) {
468​ return QRectF(cell.second * cellSize().width(),
469​ (cell.first + 1) * cellSize().height() - height,
470​ width, height);
471​ // AppletsLayout::TopToBottom:
472​ } else {
473​ return QRectF(cell.second * cellSize().width(),
474​ cell.first * cellSize().height(),
475​ width, height);
476​ }
477​ } else {
478​ cell.second = currentColumn + 1;
479​ }
480​ }
481​ }
482​
483​ //We didn't manage to find layout space, return invalid geometry
484​ return QRectF();
485​}
486​
487​
488​#include "moc_gridlayoutmanager.cpp"