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

scope this in the loop

davidedmundson: scope this in the loop
365​ for (auto *o : m_contentData) {
366​ item = qobject_cast<QQuickItem *>(o);
367​ if (item) {
368​ item->setParentItem(m_contentItem);
369​ } else {
370​ o->setParent(this);
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…
371​ }
372​ }
373​
374​ // Search for the Layout attached property
375​ // Qt6: this should become public api
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
376​ for (auto *o : children()) {
377​ if (o->inherits("QQuickLayoutAttached")) {
378​ m_layoutAttached = o;
379​ }
380​ }
381​ if (m_layoutAttached) {
382​ //NOTE: new syntax cannot be used because we don't have access to the QQuickLayoutAttached class
383​ connect(m_layoutAttached, SIGNAL(minimumHeightChanged()), m_sizeHintAdjustTimer, SLOT(start()));
384​ connect(m_layoutAttached, SIGNAL(minimumWidthChanged()), m_sizeHintAdjustTimer, SLOT(start()));
385​
386​ connect(m_layoutAttached, SIGNAL(preferredHeightChanged()), m_sizeHintAdjustTimer, SLOT(start()));
387​ connect(m_layoutAttached, SIGNAL(preferredWidthChanged()), m_sizeHintAdjustTimer, SLOT(start()));
388​
389​ connect(m_layoutAttached, SIGNAL(maximumHeightChanged()), m_sizeHintAdjustTimer, SLOT(start()));
390​ connect(m_layoutAttached, SIGNAL(maximumWidthChanged()), m_sizeHintAdjustTimer, SLOT(start()));
391​
392​ adjustSizeHints();
393​ }
394​ QQuickItem::componentComplete();
395​}
396​
397​void ItemContainer::sendUngrabRecursive(QQuickItem *item)
398​{
399​ if (!item || !item->window()) {
400​ return;
401​ }
402​
403​ for (auto *child : item->childItems()) {
404​ sendUngrabRecursive(child);
405​ }
406​
407​ QEvent ev(QEvent::UngrabMouse);
408​
409​ item->window()->sendEvent(item, &ev);
410​}
411​
412​void ItemContainer::adjustSizeHints()
413​{
414​ if (!layoutAttached() || m_editMode) {
415​ return;
416​ }
417​
418​ bool changed = false;
419​
420​ // Minimum
421​ const qreal newMinimumHeight = layoutAttached()->property("minimumHeight").toReal();
422​ const qreal newMinimumWidth = layoutAttached()->property("minimumWidth").toReal();
423​
424​ if (newMinimumHeight > height()) {
425​ setHeight(newMinimumHeight);
426​ changed = true;
427​ }
428​ if (newMinimumWidth > width()) {
429​ setWidth(newMinimumWidth);
430​ changed = true;
431​ }
432​
433​ // Preferred
434​ const qreal newPreferredHeight = layoutAttached()->property("preferredHeight").toReal();
435​ const qreal newPreferredWidth = layoutAttached()->property("preferredWidth").toReal();
436​
437​ if (newPreferredHeight > height()) {
438​ setHeight(layout()->cellHeight() * ceil(newPreferredHeight / layout()->cellHeight()));
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
439​ changed = true;
440​ }
441​ if (newPreferredWidth > width()) {
442​ setWidth(layout()->cellWidth() * ceil(newPreferredWidth / layout()->cellWidth()));
443​ changed = true;
444​ }
445​
446​ /*// Maximum : IGNORE?
447​ const qreal newMaximumHeight = layoutAttached()->property("preferredHeight").toReal();
448​ const qreal newMaximumWidth = layoutAttached()->property("preferredWidth").toReal();
449​
450​ if (newMaximumHeight > 0 && newMaximumHeight < height()) {
451​ setHeight(newMaximumHeight);
452​ changed = true;
453​ }
454​ if (newMaximumHeight > 0 && newMaximumWidth < width()) {
455​ setWidth(newMaximumWidth);
456​ changed = true;
457​ }*/
458​
459​ // Relayout if anything changed
460​ if (changed && layout()->itemIsManaged(this)) {
461​ layout()->releaseSpace(this);
462​ layout()->positionItem(this);
463​ }
464​}
465​
466​bool ItemContainer::childMouseEventFilter(QQuickItem *item, QEvent *event)
467​{
468​ // Don't filter the configoverlay
469​ if (item == m_configOverlay
470​ || (m_configOverlay && m_configOverlay->isAncestorOf(item))
471​ || (!m_editMode && m_editModeCondition == Manual)) {
472​ return QQuickItem::childMouseEventFilter(item, event);
473​ }
474​
475​ //give more time before closing
476​ if (m_closeEditModeTimer && m_closeEditModeTimer->isActive()) {
477​ m_closeEditModeTimer->start();
478​ }
479​ if (event->type() == QEvent::MouseButtonPress) {
480​ QMouseEvent *me = static_cast<QMouseEvent *>(event);
481​ if (me->button() != Qt::LeftButton && !(me->buttons() & Qt::LeftButton)) {
482​ return QQuickItem::childMouseEventFilter(item, event);
483​ }
484​ forceActiveFocus(Qt::MouseFocusReason);
485​ m_mouseDown = true;
486​ m_mouseSynthetizedFromTouch = me->source() == Qt::MouseEventSynthesizedBySystem || me->source() == Qt::MouseEventSynthesizedByQt;
487​ if (m_configOverlay) {
488​ m_configOverlay->setTouchInteraction(m_mouseSynthetizedFromTouch);
489​ }
490​
491​ const bool wasEditMode = m_editMode;
492​ if (m_layout->editMode()) {
493​ setEditMode(true);
494​ } else if (m_editModeCondition == AfterPressAndHold) {
495​ m_editModeTimer->start(QGuiApplication::styleHints()->mousePressAndHoldInterval());
496​ }
497​ m_lastMousePosition = me->windowPos();
498​ m_mouseDownPosition = me->windowPos();
499​
500​ if (m_editMode && !wasEditMode) {
501​ return true;
502​ }
503​
504​ } else if (event->type() == QEvent::MouseMove) {
505​ QMouseEvent *me = static_cast<QMouseEvent *>(event);
506​
507​ if (!m_editMode
508​ && QPointF(me->windowPos() - m_mouseDownPosition).manhattanLength() >= QGuiApplication::styleHints()->startDragDistance()) {
509​ m_editModeTimer->stop();
510​ }
511​
512​ } else if (event->type() == QEvent::MouseButtonRelease) {
513​ m_editModeTimer->stop();
514​ m_mouseDown = false;
515​ m_mouseSynthetizedFromTouch = false;
516​ ungrabMouse();
517​ }
518​
519​ return QQuickItem::childMouseEventFilter(item, event);
520​}
521​
522​void ItemContainer::mousePressEvent(QMouseEvent *event)
523​{
524​ forceActiveFocus(Qt::MouseFocusReason);
525​
526​ if (!m_editMode && m_editModeCondition == Manual) {
527​ return;
528​ }
529​
530​ m_mouseDown = true;
531​ m_mouseSynthetizedFromTouch = event->source() == Qt::MouseEventSynthesizedBySystem || event->source() == Qt::MouseEventSynthesizedByQt;
532​ if (m_configOverlay) {
533​ m_configOverlay->setTouchInteraction(m_mouseSynthetizedFromTouch);
534​ }
535​
536​ if (m_layout->editMode()) {
537​ setEditMode(true);
538​ }
539​
540​ if (m_editMode) {
541​ grabMouse();
542​ } else if (m_editModeCondition == AfterPressAndHold) {
543​ m_editModeTimer->start(QGuiApplication::styleHints()->mousePressAndHoldInterval());
544​ }
545​
546​ m_lastMousePosition = event->windowPos();
547​ m_mouseDownPosition = event->windowPos();
548​ event->accept();
549​}
550​
551​void ItemContainer::mouseReleaseEvent(QMouseEvent *event)
552​{
553​ Q_UNUSED(event);
554​
555​ if (!m_layout
556​ || (!m_editMode && m_editModeCondition == Manual)) {
557​ return;
558​ }
559​
560​ m_mouseDown = false;
561​ m_mouseSynthetizedFromTouch = false;
562​ m_editModeTimer->stop();
563​ ungrabMouse();
564​
565​ if (m_editMode && !m_layout->itemIsManaged(this)) {
566​ m_layout->hidePlaceHolder();
567​ m_layout->positionItem(this);
568​ }
569​}
570​
571​void ItemContainer::mouseMoveEvent(QMouseEvent *event)
572​{
573​ if ((event->button() == Qt::NoButton && event->buttons() == Qt::NoButton)
574​ || !m_layout
575​ || (!m_editMode && m_editModeCondition == Manual)) {
576​ return;
577​ }
578​
579​ if (!m_editMode
580​ && QPointF(event->windowPos() - m_mouseDownPosition).manhattanLength() >= QGuiApplication::styleHints()->startDragDistance()) {
581​ if (m_editModeCondition == AfterPress) {
582​ setEditMode(true);
583​ } else {
584​ m_editModeTimer->stop();
585​ }
586​ }
587​
588​ if (!m_editMode) {
589​ return;
590​ }
591​
592​ if (m_layout->itemIsManaged(this)) {
593​ m_layout->releaseSpace(this);
594​ grabMouse();
595​
596​ } else {
597​ setX(x() + event->windowPos().x() - m_lastMousePosition.x());
598​ setY(y() + event->windowPos().y() - m_lastMousePosition.y());
599​
600​ m_layout->showPlaceHolderForItem(this);
601​
602​ emit userDrag(QPointF(x(), y()), event->pos());
603​ }
604​ m_lastMousePosition = event->windowPos();
605​}
606​
607​void ItemContainer::mouseUngrabEvent()
608​{
609​ m_mouseDown = false;
610​ m_mouseSynthetizedFromTouch = false;
611​ m_editModeTimer->stop();
612​ ungrabMouse();
613​
614​ if (m_editMode && !m_layout->itemIsManaged(this)) {
615​ m_layout->hidePlaceHolder();
616​ m_layout->positionItem(this);
617​ }
618​}
619​
620​void ItemContainer::hoverEnterEvent(QHoverEvent *event)
621​{
622​ Q_UNUSED(event);
623​
624​ if (m_editModeCondition != AfterMouseOver) {
625​ return;
626​ }
627​
628​ if (m_closeEditModeTimer) {
629​ m_closeEditModeTimer->stop();
630​ }
631​
632​ m_editModeTimer->start(QGuiApplication::styleHints()->mousePressAndHoldInterval());
633​}
634​
635​void ItemContainer::hoverLeaveEvent(QHoverEvent *event)
636​{
637​ Q_UNUSED(event);
638​
639​ if (m_editModeCondition != AfterMouseOver) {
640​ return;
641​ }
642​
643​ m_editModeTimer->stop();
644​ if (!m_closeEditModeTimer) {
645​ m_closeEditModeTimer = new QTimer(this);
646​ m_closeEditModeTimer->setSingleShot(true);
647​ m_closeEditModeTimer->setInterval(500);
648​ connect(m_closeEditModeTimer, &QTimer::timeout, this, [this] () {
649​ setEditMode(false);
650​ });
651​ }
652​ m_closeEditModeTimer->start();
653​}
654​
655​QQuickItem *ItemContainer::contentItem() const
656​{
657​ return m_contentItem;
658​}
659​
660​void ItemContainer::setContentItem(QQuickItem *item)
661​{
662​ if (m_contentItem == item) {
663​ return;
664​ }
665​
666​ m_contentItem = item;
667​ item->setParentItem(this);
668​ m_contentItem->setX(m_leftPadding);
669​ m_contentItem->setY(m_topPadding);
670​
671​ m_contentItem->setSize(QSizeF(width() - m_leftPadding - m_rightPadding,
672​ height() - m_topPadding - m_bottomPadding));
673​
674​ adjustSizeHints();
675​ emit contentItemChanged();
676​}
677​
678​QQuickItem *ItemContainer::background() const
679​{
680​ return m_backgroundItem;
681​}
682​
683​void ItemContainer::setBackground(QQuickItem *item)
684​{
685​ if (m_backgroundItem == item) {
686​ return;
687​ }
688​
689​ m_backgroundItem = item;
690​ m_backgroundItem->setParentItem(this);
691​ m_backgroundItem->setX(0);
692​ m_backgroundItem->setY(0);
693​ m_backgroundItem->setSize(size());
694​
695​ emit backgroundChanged();
696​}
697​
698​int ItemContainer::leftPadding() const
699​{
700​ return m_leftPadding;
701​}
702​
703​void ItemContainer::setLeftPadding(int padding)
704​{
705​ if (m_leftPadding == padding) {
706​ return;
707​ }
708​
709​ m_leftPadding = padding;
710​ syncChildItemsGeometry(size());
711​ emit leftPaddingChanged();
712​ emit contentWidthChanged();
713​}
714​
715​
716​int ItemContainer::topPadding() const
717​{
718​ return m_topPadding;
719​}
720​
721​void ItemContainer::setTopPadding(int padding)
722​{
723​ if (m_topPadding == padding) {
724​ return;
725​ }
726​
727​ m_topPadding = padding;
728​ syncChildItemsGeometry(size());
729​ emit topPaddingChanged();
730​ emit contentHeightChanged();
731​}
732​
733​
734​int ItemContainer::rightPadding() const
735​{
736​ return m_rightPadding;
737​}
738​
739​void ItemContainer::setRightPadding(int padding)
740​{
741​ if (m_rightPadding == padding) {
742​ return;
743​ }
744​
745​ m_rightPadding = padding;
746​ syncChildItemsGeometry(size());
747​ emit rightPaddingChanged();
748​ emit contentWidthChanged();
749​}
750​
751​
752​int ItemContainer::bottomPadding() const
753​{
754​ return m_bottomPadding;
755​}
756​
757​void ItemContainer::setBottomPadding(int padding)
758​{
759​ if (m_bottomPadding == padding) {
760​ return;
761​ }
762​
763​ m_bottomPadding = padding;
764​ syncChildItemsGeometry(size());
765​ emit bottomPaddingChanged();
766​ emit contentHeightChanged();
767​}
768​
769​int ItemContainer::contentWidth() const
770​{
771​ return width() - m_leftPadding - m_rightPadding;
772​}
773​
774​int ItemContainer::contentHeight() const
775​{
776​ return height() - m_topPadding - m_bottomPadding;
777​}
778​
779​#include "moc_itemcontainer.cpp"