Differential D22034 Diff 61987 components/containmentlayoutmanager/itemcontainer.cpp

Changeset View

Standalone View

View Options

components/containmentlayoutmanager/itemcontainer.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 "itemcontainer.h"
22​#include "configoverlay.h"
23​
24​#include <cmath>
25​#include <QQmlEngine>
26​#include <QQmlContext>
27​#include <QQuickWindow>
28​#include <QTimer>
29​#include <QGuiApplication>
30​#include <QStyleHints>
31​
32​#include <PlasmaQuick/AppletQuickItem>
33​
34​ItemContainer::ItemContainer(QQuickItem *parent)
35​ : QQuickItem(parent)
36​{
37​ setFiltersChildMouseEvents(true);
38​ setFlags(QQuickItem::ItemIsFocusScope);
39​ setActiveFocusOnTab(true);
40​ setAcceptedMouseButtons(Qt::LeftButton);
41​
42​ setLayout(qobject_cast<AppletsLayout *>(parent));
43​
44​ m_editModeTimer = new QTimer(this);
45​ m_editModeTimer->setSingleShot(true);
46​
47​ connect(this, &QQuickItem::parentChanged, this, [this]() {
48​ setLayout(qobject_cast<AppletsLayout *>(parentItem()));
49​ });
50​
51​ connect(m_editModeTimer, &QTimer::timeout, this, [this]() {
52​ setEditMode(true);
53​ });
54​
55​
56​ m_sizeHintAdjustTimer = new QTimer(this);
57​ m_sizeHintAdjustTimer->setSingleShot(true);
58​ m_sizeHintAdjustTimer->setInterval(0);
59​
60​ connect(m_sizeHintAdjustTimer, &QTimer::timeout, this, &ItemContainer::sizeHintsChanged);
61​
62​ // Lose edit mode when going out of focus
63​ connect(this, &QQuickItem::focusChanged, this, [this]() {
64​ if (!hasFocus()) {
65​ setEditMode(false);
66​ }
67​ });
68​}
69​
70​ItemContainer::~ItemContainer()
71​{
72​ if (m_contentItem) {
73​ m_contentItem->setEnabled(true);
74​ }
75​}
76​
77​QString ItemContainer::key() const
78​{
79​ return m_key;
80​}
81​
82​void ItemContainer::setKey(const QString &key)
83​{
84​ if (m_key == key) {
85​ return;
86​ }
87​
88​ m_key = key;
89​
90​ emit keyChanged();
91​}
92​
93​bool ItemContainer::editMode() const
94​{
95​ return m_editMode;
96​}
97​
98​void ItemContainer::setEditMode(bool editMode)
99​{
100​ if (m_editMode == editMode) {
101​ return;
102​ }
103​
104​ if (editMode && editModeCondition() == Locked) {
105​ return;
106​ }
107​
108​ m_editMode = editMode;
109​
110​ // Leave this decision to QML?
111​ if (m_editModeCondition != AfterMouseOver || m_layout->editMode()) {
112​ m_contentItem->setEnabled(!editMode);
113​ }
114​
115​ if (editMode) {
116​ setZ(1);
117​ } else {
118​ setZ(0);
119​ }
120​
121​ if (m_mouseDown) {
122​ sendUngrabRecursive(m_contentItem);
123​ grabMouse();
124​ }
125​
126​ setConfigOverlayVisible(editMode);
127​
128​ emit editModeChanged(editMode);
129​}
130​
131​ItemContainer::EditModeCondition ItemContainer::editModeCondition() const
132​{
133​ if (m_layout->editModeCondition() == AppletsLayout::Locked) {
134​ return Locked;
135​ }
136​
137​ return m_editModeCondition;
138​}
139​
140​void ItemContainer::setEditModeCondition(EditModeCondition condition)
141​{
142​ if (condition == m_editModeCondition) {
143​ return;
144​ }
145​
146​ if (condition == Locked) {
147​ setEditMode(false);
148​ }
149​
150​ m_editModeCondition = condition;
151​
152​ setAcceptHoverEvents(condition == AfterMouseOver);
153​
154​ emit editModeConditionChanged();
155​}
156​
157​AppletsLayout::PreferredLayoutDirection ItemContainer::preferredLayoutDirection() const
158​{
159​ return m_preferredLayoutDirection;
160​}
161​
162​void ItemContainer::setPreferredLayoutDirection(AppletsLayout::PreferredLayoutDirection direction)
163​{
164​ if (direction == m_preferredLayoutDirection) {
165​ return;
166​ }
167​
168​ m_preferredLayoutDirection = direction;
169​
170​ emit preferredLayoutDirectionChanged();
171​}
172​
173​void ItemContainer::setLayout(AppletsLayout *layout)
174​{
175​ if (m_layout == layout) {
176​ return;
177​ }
178​
179​ m_layout = layout;
180​ if (parentItem() != layout) {
181​ setParentItem(layout);
182​ }
183​
184​ connect(m_layout, &AppletsLayout::editModeConditionChanged, this, [this]() {
185​ if (m_layout->editModeCondition() == AppletsLayout::Locked) {
186​ setEditMode(false);
187​ }
188​ if ((m_layout->editModeCondition() == AppletsLayout::Locked) !=
189​ (m_editModeCondition == ItemContainer::Locked)) {
190​ emit editModeConditionChanged();
191​ }
192​ });
193​ emit layoutChanged();
194​}
195​
196​AppletsLayout *ItemContainer::layout() const
197​{
198​ return m_layout;
199​}
200​
201​void ItemContainer::syncChildItemsGeometry(const QSizeF &size)
202​{
203​ if (m_contentItem) {
204​ m_contentItem->setPosition(QPointF(m_leftPadding, m_topPadding));
205​
206​ m_contentItem->setSize(QSizeF(size.width() - m_leftPadding - m_rightPadding,
207​ size.height() - m_topPadding - m_bottomPadding));
208​ }
209​
210​ if (m_backgroundItem) {
211​ m_backgroundItem->setPosition(QPointF(0, 0));
212​ m_backgroundItem->setSize(size);
213​ }
214​
215​ if (m_configOverlay) {
216​ m_configOverlay->setPosition(QPointF(0, 0));
217​ m_configOverlay->setSize(size);
218​ }
219​}
220​
221​QQmlComponent *ItemContainer::configOverlayComponent() const
222​{
223​ return m_configOverlayComponent;
224​}
225​
226​void ItemContainer::setConfigOverlayComponent(QQmlComponent *component)
227​{
228​ if (component == m_configOverlayComponent) {
229​ return;
230​ }
231​
232​ m_configOverlayComponent = component;
233​ if (m_configOverlay) {
234​ m_configOverlay->deleteLater();
235​ m_configOverlay = nullptr;
236​ }
237​
238​ emit configOverlayComponentChanged();
239​}
240​
241​ConfigOverlay *ItemContainer::configOverlayItem() const
242​{
243​ return m_configOverlay;
244​}
245​
246​QSizeF ItemContainer::initialSize() const
247​{
248​ return m_initialSize;
249​}
250​
251​void ItemContainer::setInitialSize(const QSizeF &size)
252​{
253​ if (m_initialSize == size) {
254​ return;
255​ }
256​
257​ m_initialSize = size;
258​
259​ emit initialSizeChanged();
260​}
261​
262​bool ItemContainer::configOverlayVisible() const
263​{
264​ return m_configOverlay && m_configOverlay->open();
265​}
266​
267​void ItemContainer::setConfigOverlayVisible(bool visible)
268​{
269​ if (!m_configOverlayComponent) {
270​ return;
271​ }
272​
273​ if (visible == configOverlayVisible()) {
274​ return;
275​ }
276​
277​ if (visible && !m_configOverlay) {
278​ QQmlContext *context = QQmlEngine::contextForObject(this);
279​ Q_ASSERT(context);
280​ QObject *instance = m_configOverlayComponent->beginCreate(context);
281​ m_configOverlay = qobject_cast<ConfigOverlay *>(instance);
282​
283​ if (!m_configOverlay) {
284​ qWarning() << "Error: Applet configOverlay not of ConfigOverlay type";
285​ if (instance) {
286​ instance->deleteLater();
287​ }
288​ return;
289​ }
290​
291​ m_configOverlay->setVisible(false);
292​ m_configOverlay->setItemContainer(this);
293​ m_configOverlay->setParentItem(this);
294​ m_configOverlay->setTouchInteraction(m_mouseSynthetizedFromTouch);
295​ m_configOverlay->setZ(999);
296​ m_configOverlay->setPosition(QPointF(0, 0));
297​ m_configOverlay->setSize(size());
298​
299​ m_configOverlayComponent->completeCreate();
300​
301​ connect(m_configOverlay, &ConfigOverlay::openChanged, this, [this]() {
302​ emit configOverlayVisibleChanged(m_configOverlay->open());
303​ });
304​
305​ emit configOverlayItemChanged();
306​ }
307​
308​ if (m_configOverlay) {
309​ m_configOverlay->setOpen(visible);
310​ }
311​}
312​
313​void ItemContainer::contentData_append(QQmlListProperty<QObject> *prop, QObject *object)
314​{
315​ ItemContainer *container = static_cast<ItemContainer *>(prop->object);
316​ if (!container) {
317​ return;
318​ }
319​
320​// QQuickItem *item = qobject_cast<QQuickItem *>(object);
321​ container->m_contentData.append(object);
322​}
323​
324​int ItemContainer::contentData_count(QQmlListProperty<QObject> *prop)
325​{
326​ ItemContainer *container = static_cast<ItemContainer *>(prop->object);
327​ if (!container) {
328​ return 0;
329​ }
330​
331​ return container->m_contentData.count();
332​}
333​
334​QObject *ItemContainer::contentData_at(QQmlListProperty<QObject> *prop, int index)
335​{
336​ ItemContainer *container = static_cast<ItemContainer *>(prop->object);
337​ if (!container) {
338​ return nullptr;
339​ }
340​
341​ if (index < 0 || index >= container->m_contentData.count()) {
342​ return nullptr;
343​ }
344​ return container->m_contentData.value(index);
345​}
346​
347​void ItemContainer::contentData_clear(QQmlListProperty<QObject> *prop)
348​{
349​ ItemContainer *container = static_cast<ItemContainer *>(prop->object);
350​ if (!container) {
351​ return;
352​ }
353​
354​ return container->m_contentData.clear();
355​}
356​
357​QQmlListProperty<QObject> ItemContainer::contentData()
358​{
359​ return QQmlListProperty<QObject>(this, nullptr,
360​ contentData_append,
361​ contentData_count,
362​ contentData_at,
363​ contentData_clear);
364​}
365​
davidedmundsonUnsubmitted
Done

scope this in the loop

davidedmundson: scope this in the loop
366​void ItemContainer::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
367​{
368​ syncChildItemsGeometry(newGeometry.size());
369​ QQuickItem::geometryChanged(newGeometry, oldGeometry);
370​ emit contentWidthChanged();
371​ emit contentHeightChanged();
davidedmundsonUnsubmitted
Done

why?

davidedmundson: why?
martAuthorUnsubmitted
Done

I may be wrong but I think if one would do
AppletsLayout {

QtObject {}

}

that internal object wouldn't be parented and stay dangling otherwise?

mart: I may be wrong but I think if one would do AppletsLayout { QtObject {} } that internal…
davidedmundsonUnsubmitted
Done

AFAIK, QML created objects don't use QObject parent.

Instead there's a ref counting thing in the JS engine.

davidedmundson: AFAIK, QML created objects don't use QObject parent. Instead there's a ref counting thing in…
372​}
373​
374​void ItemContainer::componentComplete()
375​{
376​ if (!m_contentItem) {
davidedmundsonUnsubmitted
Done

no point just wishing, we need to open a bug report at least

davidedmundson: no point just wishing, we need to open a bug report at least
377​ //qWarning()<<"Creting default contentItem";
378​ m_contentItem = new QQuickItem(this);
379​ syncChildItemsGeometry(size());
380​ }
381​
382​ for (auto *o : m_contentData) {
383​ QQuickItem *item = qobject_cast<QQuickItem *>(o);
384​ if (item) {
385​ item->setParentItem(m_contentItem);
386​ }
387​ }
388​
389​ // Search for the Layout attached property
390​ // Qt6: this should become public api
391​ // https://bugreports.qt.io/browse/QTBUG-77103
392​ for (auto *o : children()) {
393​ if (o->inherits("QQuickLayoutAttached")) {
394​ m_layoutAttached = o;
395​ }
396​ }
397​
398​ if (m_layoutAttached) {
399​ //NOTE: new syntax cannot be used because we don't have access to the QQuickLayoutAttached class
400​ connect(m_layoutAttached, SIGNAL(minimumHeightChanged()), m_sizeHintAdjustTimer, SLOT(start()));
401​ connect(m_layoutAttached, SIGNAL(minimumWidthChanged()), m_sizeHintAdjustTimer, SLOT(start()));
402​
403​ connect(m_layoutAttached, SIGNAL(preferredHeightChanged()), m_sizeHintAdjustTimer, SLOT(start()));
404​ connect(m_layoutAttached, SIGNAL(preferredWidthChanged()), m_sizeHintAdjustTimer, SLOT(start()));
405​
406​ connect(m_layoutAttached, SIGNAL(maximumHeightChanged()), m_sizeHintAdjustTimer, SLOT(start()));
407​ connect(m_layoutAttached, SIGNAL(maximumWidthChanged()), m_sizeHintAdjustTimer, SLOT(start()));
408​ }
409​ QQuickItem::componentComplete();
410​}
411​
412​void ItemContainer::sendUngrabRecursive(QQuickItem *item)
413​{
414​ if (!item || !item->window()) {
415​ return;
416​ }
417​
418​ for (auto *child : item->childItems()) {
419​ sendUngrabRecursive(child);
420​ }
421​
422​ QEvent ev(QEvent::UngrabMouse);
423​
424​ item->window()->sendEvent(item, &ev);
425​}
426​
427​bool ItemContainer::childMouseEventFilter(QQuickItem *item, QEvent *event)
428​{
429​ // Don't filter the configoverlay
430​ if (item == m_configOverlay
431​ || (m_configOverlay && m_configOverlay->isAncestorOf(item))
432​ || (!m_editMode && m_editModeCondition == Manual)) {
433​ return QQuickItem::childMouseEventFilter(item, event);
434​ }
435​
436​ //give more time before closing
437​ if (m_closeEditModeTimer && m_closeEditModeTimer->isActive()) {
438​ m_closeEditModeTimer->start();
439​ }
davidedmundsonUnsubmitted
Not Done

why?

We're above the minimum size, the user could have resized it smaller than this

davidedmundson: why? We're above the minimum size, the user could have resized it smaller than this
martAuthorUnsubmitted
Not Done

This may be not necessary, depends the behavior we want.
The test i did was with the system monitor, having it auto resize when one adds a sensor seemed to look better...
It depends from usability pov, if instead by design we say the size the user manually put is more important and should be maintained if possible, then this part would go.

mart: This may be not necessary, depends the behavior we want. The test i did was with the system…
davidedmundsonUnsubmitted
Done

If we want to use this in the panel/wherever we need ItemContainer to forward the full min/preferred/max sizes (with margins added) and have the LayoutManager be the one that takes this information and resizes the container.

IMHO it shouldn't resize itself, it should just emit sizeHintChanged

Then in AbstractLayoutManager we have a connect that does the current:

releaseSpace(item)
resizeFromSizeHints(item)
positionItem(item)

It then gives full absolute control to the manager, rather than it doing part and then the item doing part.

davidedmundson: If we want to use this in the panel/wherever we need ItemContainer to forward the full…
martAuthorUnsubmitted
Not Done

same code now moved in the layoutmanager

mart: same code now moved in the layoutmanager
440​ if (event->type() == QEvent::MouseButtonPress) {
441​ QMouseEvent *me = static_cast<QMouseEvent *>(event);
442​ if (me->button() != Qt::LeftButton && !(me->buttons() & Qt::LeftButton)) {
443​ return QQuickItem::childMouseEventFilter(item, event);
444​ }
445​ forceActiveFocus(Qt::MouseFocusReason);
446​ m_mouseDown = true;
447​ m_mouseSynthetizedFromTouch = me->source() == Qt::MouseEventSynthesizedBySystem || me->source() == Qt::MouseEventSynthesizedByQt;
448​ if (m_configOverlay) {
449​ m_configOverlay->setTouchInteraction(m_mouseSynthetizedFromTouch);
450​ }
451​
452​ const bool wasEditMode = m_editMode;
453​ if (m_layout->editMode()) {
454​ setEditMode(true);
455​ } else if (m_editModeCondition == AfterPressAndHold) {
456​ m_editModeTimer->start(QGuiApplication::styleHints()->mousePressAndHoldInterval());
457​ }
458​ m_lastMousePosition = me->windowPos();
459​ m_mouseDownPosition = me->windowPos();
460​
461​ if (m_editMode && !wasEditMode) {
462​ return true;
463​ }
464​
465​ } else if (event->type() == QEvent::MouseMove) {
466​ QMouseEvent *me = static_cast<QMouseEvent *>(event);
467​
468​ if (!m_editMode
469​ && QPointF(me->windowPos() - m_mouseDownPosition).manhattanLength() >= QGuiApplication::styleHints()->startDragDistance()) {
470​ m_editModeTimer->stop();
471​ }
472​
473​ } else if (event->type() == QEvent::MouseButtonRelease) {
474​ m_editModeTimer->stop();
475​ m_mouseDown = false;
476​ m_mouseSynthetizedFromTouch = false;
477​ ungrabMouse();
478​ }
479​
480​ return QQuickItem::childMouseEventFilter(item, event);
481​}
482​
483​void ItemContainer::mousePressEvent(QMouseEvent *event)
484​{
485​ forceActiveFocus(Qt::MouseFocusReason);
486​
487​ if (!m_editMode && m_editModeCondition == Manual) {
488​ return;
489​ }
490​
491​ m_mouseDown = true;
492​ m_mouseSynthetizedFromTouch = event->source() == Qt::MouseEventSynthesizedBySystem || event->source() == Qt::MouseEventSynthesizedByQt;
493​ if (m_configOverlay) {
494​ m_configOverlay->setTouchInteraction(m_mouseSynthetizedFromTouch);
495​ }
496​
497​ if (m_layout->editMode()) {
498​ setEditMode(true);
499​ }
500​
501​ if (m_editMode) {
502​ grabMouse();
503​ } else if (m_editModeCondition == AfterPressAndHold) {
504​ m_editModeTimer->start(QGuiApplication::styleHints()->mousePressAndHoldInterval());
505​ }
506​
507​ m_lastMousePosition = event->windowPos();
508​ m_mouseDownPosition = event->windowPos();
509​ event->accept();
510​}
511​
512​void ItemContainer::mouseReleaseEvent(QMouseEvent *event)
513​{
514​ Q_UNUSED(event);
515​
516​ if (!m_layout
517​ || (!m_editMode && m_editModeCondition == Manual)) {
518​ return;
519​ }
520​
521​ m_mouseDown = false;
522​ m_mouseSynthetizedFromTouch = false;
523​ m_editModeTimer->stop();
524​ ungrabMouse();
525​
526​ if (m_editMode && !m_layout->itemIsManaged(this)) {
527​ m_layout->hidePlaceHolder();
528​ m_layout->positionItem(this);
529​ }
530​}
531​
532​void ItemContainer::mouseMoveEvent(QMouseEvent *event)
533​{
534​ if ((event->button() == Qt::NoButton && event->buttons() == Qt::NoButton)
535​ || !m_layout
536​ || (!m_editMode && m_editModeCondition == Manual)) {
537​ return;
538​ }
539​
540​ if (!m_editMode
541​ && QPointF(event->windowPos() - m_mouseDownPosition).manhattanLength() >= QGuiApplication::styleHints()->startDragDistance()) {
542​ if (m_editModeCondition == AfterPress) {
543​ setEditMode(true);
544​ } else {
545​ m_editModeTimer->stop();
546​ }
547​ }
548​
549​ if (!m_editMode) {
550​ return;
551​ }
552​
553​ if (m_layout->itemIsManaged(this)) {
554​ m_layout->releaseSpace(this);
555​ grabMouse();
556​
557​ } else {
558​ setPosition(QPointF(x() + event->windowPos().x() - m_lastMousePosition.x(),
559​ y() + event->windowPos().y() - m_lastMousePosition.y()));
560​
561​ m_layout->showPlaceHolderForItem(this);
562​
563​ emit userDrag(QPointF(x(), y()), event->pos());
564​ }
565​ m_lastMousePosition = event->windowPos();
566​}
567​
568​void ItemContainer::mouseUngrabEvent()
569​{
570​ m_mouseDown = false;
571​ m_mouseSynthetizedFromTouch = false;
572​ m_editModeTimer->stop();
573​ ungrabMouse();
574​
575​ if (m_editMode && !m_layout->itemIsManaged(this)) {
576​ m_layout->hidePlaceHolder();
577​ m_layout->positionItem(this);
578​ }
579​}
580​
581​void ItemContainer::hoverEnterEvent(QHoverEvent *event)
582​{
583​ Q_UNUSED(event);
584​
585​ if (m_editModeCondition != AfterMouseOver) {
586​ return;
587​ }
588​
589​ if (m_closeEditModeTimer) {
590​ m_closeEditModeTimer->stop();
591​ }
592​
593​ m_editModeTimer->start(QGuiApplication::styleHints()->mousePressAndHoldInterval());
594​}
595​
596​void ItemContainer::hoverLeaveEvent(QHoverEvent *event)
597​{
598​ Q_UNUSED(event);
599​
600​ if (m_editModeCondition != AfterMouseOver) {
601​ return;
602​ }
603​
604​ m_editModeTimer->stop();
605​ if (!m_closeEditModeTimer) {
606​ m_closeEditModeTimer = new QTimer(this);
607​ m_closeEditModeTimer->setSingleShot(true);
608​ m_closeEditModeTimer->setInterval(500);
609​ connect(m_closeEditModeTimer, &QTimer::timeout, this, [this] () {
610​ setEditMode(false);
611​ });
612​ }
613​ m_closeEditModeTimer->start();
614​}
615​
616​QQuickItem *ItemContainer::contentItem() const
617​{
618​ return m_contentItem;
619​}
620​
621​void ItemContainer::setContentItem(QQuickItem *item)
622​{
623​ if (m_contentItem == item) {
624​ return;
625​ }
626​
627​ m_contentItem = item;
628​ item->setParentItem(this);
629​ m_contentItem->setPosition(QPointF(m_leftPadding, m_topPadding));
630​
631​ m_contentItem->setSize(QSizeF(width() - m_leftPadding - m_rightPadding,
632​ height() - m_topPadding - m_bottomPadding));
633​
634​ emit contentItemChanged();
635​}
636​
637​QQuickItem *ItemContainer::background() const
638​{
639​ return m_backgroundItem;
640​}
641​
642​void ItemContainer::setBackground(QQuickItem *item)
643​{
644​ if (m_backgroundItem == item) {
645​ return;
646​ }
647​
648​ m_backgroundItem = item;
649​ m_backgroundItem->setParentItem(this);
650​ m_backgroundItem->setPosition(QPointF(0, 0));
651​ m_backgroundItem->setSize(size());
652​
653​ emit backgroundChanged();
654​}
655​
656​int ItemContainer::leftPadding() const
657​{
658​ return m_leftPadding;
659​}
660​
661​void ItemContainer::setLeftPadding(int padding)
662​{
663​ if (m_leftPadding == padding) {
664​ return;
665​ }
666​
667​ m_leftPadding = padding;
668​ syncChildItemsGeometry(size());
669​ emit leftPaddingChanged();
670​ emit contentWidthChanged();
671​}
672​
673​
674​int ItemContainer::topPadding() const
675​{
676​ return m_topPadding;
677​}
678​
679​void ItemContainer::setTopPadding(int padding)
680​{
681​ if (m_topPadding == padding) {
682​ return;
683​ }
684​
685​ m_topPadding = padding;
686​ syncChildItemsGeometry(size());
687​ emit topPaddingChanged();
688​ emit contentHeightChanged();
689​}
690​
691​
692​int ItemContainer::rightPadding() const
693​{
694​ return m_rightPadding;
695​}
696​
697​void ItemContainer::setRightPadding(int padding)
698​{
699​ if (m_rightPadding == padding) {
700​ return;
701​ }
702​
703​ m_rightPadding = padding;
704​ syncChildItemsGeometry(size());
705​ emit rightPaddingChanged();
706​ emit contentWidthChanged();
707​}
708​
709​
710​int ItemContainer::bottomPadding() const
711​{
712​ return m_bottomPadding;
713​}
714​
715​void ItemContainer::setBottomPadding(int padding)
716​{
717​ if (m_bottomPadding == padding) {
718​ return;
719​ }
720​
721​ m_bottomPadding = padding;
722​ syncChildItemsGeometry(size());
723​ emit bottomPaddingChanged();
724​ emit contentHeightChanged();
725​}
726​
727​int ItemContainer::contentWidth() const
728​{
729​ return width() - m_leftPadding - m_rightPadding;
730​}
731​
732​int ItemContainer::contentHeight() const
733​{
734​ return height() - m_topPadding - m_bottomPadding;
735​}
736​
737​#include "moc_itemcontainer.cpp"