1 | // Copyright (C) 2022 The Qt Company Ltd. |
---|---|
2 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only |
3 | |
4 | #include "qquicksplitview_p.h" |
5 | #include "qquicksplitview_p_p.h" |
6 | #include "qquickcontentitem_p.h" |
7 | |
8 | #include <QtCore/qdebug.h> |
9 | #include <QtCore/qloggingcategory.h> |
10 | #include <QtCore/qcborarray.h> |
11 | #include <QtCore/qcbormap.h> |
12 | #include <QtCore/qcborvalue.h> |
13 | #include <QtQml/QQmlInfo> |
14 | |
15 | QT_BEGIN_NAMESPACE |
16 | |
17 | /*! |
18 | \qmltype SplitView |
19 | \inherits Container |
20 | //! \nativetype QQuickSplitView |
21 | \inqmlmodule QtQuick.Controls |
22 | \since 5.13 |
23 | \ingroup qtquickcontrols-containers |
24 | \ingroup qtquickcontrols-focusscopes |
25 | \brief Lays out items with a draggable splitter between each item. |
26 | |
27 | SplitView is a control that lays out items horizontally or vertically with |
28 | a draggable splitter between each item. |
29 | |
30 | SplitView supports the following attached properties on items it manages: |
31 | |
32 | \list |
33 | \li \l{minimumWidth}{SplitView.minimumWidth} |
34 | \li \l{minimumHeight}{SplitView.minimumHeight} |
35 | \li \l{preferredWidth}{SplitView.preferredWidth} |
36 | \li \l{preferredHeight}{SplitView.preferredHeight} |
37 | \li \l{maximumWidth}{SplitView.maximumWidth} |
38 | \li \l{maximumHeight}{SplitView.maximumHeight} |
39 | \li \l{fillWidth}{SplitView.fillWidth} (true for only one child) |
40 | \li \l{fillHeight}{SplitView.fillHeight} (true for only one child) |
41 | \endlist |
42 | |
43 | In addition, each handle has the following read-only attached properties: |
44 | |
45 | \list |
46 | \li \l{SplitHandle::hovered}{SplitHandle.hovered} |
47 | \li \l{SplitHandle::pressed}{SplitHandle.pressed} |
48 | \endlist |
49 | |
50 | \note Handles should be purely visual and not handle events, as it can |
51 | interfere with their hovered and pressed states. |
52 | |
53 | The preferred size of items in a SplitView can be specified via |
54 | \l{Item::}{implicitWidth} and \l{Item::}{implicitHeight} or |
55 | \c SplitView.preferredWidth and \c SplitView.preferredHeight: |
56 | |
57 | \code |
58 | SplitView { |
59 | anchors.fill: parent |
60 | |
61 | Item { |
62 | SplitView.preferredWidth: 50 |
63 | } |
64 | |
65 | // ... |
66 | } |
67 | \endcode |
68 | |
69 | For a horizontal SplitView, it's not necessary to specify the preferred |
70 | height of each item, as they will be resized to the height of the view. |
71 | This applies in reverse for vertical views. |
72 | |
73 | When a split handle is dragged, the \c SplitView.preferredWidth or |
74 | \c SplitView.preferredHeight property is overwritten, depending on the |
75 | \l orientation of the view. |
76 | |
77 | To limit the size of items in a horizontal view, use the following |
78 | properties: |
79 | |
80 | \code |
81 | SplitView { |
82 | anchors.fill: parent |
83 | |
84 | Item { |
85 | SplitView.minimumWidth: 25 |
86 | SplitView.preferredWidth: 50 |
87 | SplitView.maximumWidth: 100 |
88 | } |
89 | |
90 | // ... |
91 | } |
92 | \endcode |
93 | |
94 | To limit the size of items in a vertical view, use the following |
95 | properties: |
96 | |
97 | \code |
98 | SplitView { |
99 | anchors.fill: parent |
100 | orientation: Qt.Vertical |
101 | |
102 | Item { |
103 | SplitView.minimumHeight: 25 |
104 | SplitView.preferredHeight: 50 |
105 | SplitView.maximumHeight: 100 |
106 | } |
107 | |
108 | // ... |
109 | } |
110 | \endcode |
111 | |
112 | There will always be one item (the fill item) in the SplitView that has |
113 | \c SplitView.fillWidth set to \c true (or \c SplitView.fillHeight, if |
114 | \l orientation is \c Qt.Vertical). This means that the item will get all |
115 | leftover space when other items have been laid out. By default, the last |
116 | visible child of the SplitView will have this set, but it can be changed by |
117 | explicitly setting \c fillWidth to \c true on another item. |
118 | |
119 | A handle can belong to the item either on the left or top side, or on the |
120 | right or bottom side: |
121 | |
122 | \list |
123 | \li If the fill item is to the right: the handle belongs to the left |
124 | item. |
125 | \li If the fill item is on the left: the handle belongs to the right |
126 | item. |
127 | \endlist |
128 | |
129 | To create a SplitView with three items, and let the center item get |
130 | superfluous space, one could do the following: |
131 | |
132 | \code |
133 | SplitView { |
134 | anchors.fill: parent |
135 | orientation: Qt.Horizontal |
136 | |
137 | Rectangle { |
138 | implicitWidth: 200 |
139 | SplitView.maximumWidth: 400 |
140 | color: "lightblue" |
141 | Label { |
142 | text: "View 1" |
143 | anchors.centerIn: parent |
144 | } |
145 | } |
146 | Rectangle { |
147 | id: centerItem |
148 | SplitView.minimumWidth: 50 |
149 | SplitView.fillWidth: true |
150 | color: "lightgray" |
151 | Label { |
152 | text: "View 2" |
153 | anchors.centerIn: parent |
154 | } |
155 | } |
156 | Rectangle { |
157 | implicitWidth: 200 |
158 | color: "lightgreen" |
159 | Label { |
160 | text: "View 3" |
161 | anchors.centerIn: parent |
162 | } |
163 | } |
164 | } |
165 | \endcode |
166 | |
167 | \section1 Serializing SplitView's State |
168 | |
169 | The main purpose of SplitView is to allow users to easily configure the |
170 | size of various UI elements. In addition, the user's preferred sizes should |
171 | be remembered across sessions. To achieve this, the values of the \c |
172 | SplitView.preferredWidth and \c SplitView.preferredHeight properties can be |
173 | serialized using the \l saveState() and \l restoreState() functions: |
174 | |
175 | \qml |
176 | import QtCore |
177 | import QtQuick.Controls |
178 | |
179 | ApplicationWindow { |
180 | // ... |
181 | |
182 | Component.onCompleted: splitView.restoreState(settings.splitView) |
183 | Component.onDestruction: settings.splitView = splitView.saveState() |
184 | |
185 | Settings { |
186 | id: settings |
187 | property var splitView |
188 | } |
189 | |
190 | SplitView { |
191 | id: splitView |
192 | // ... |
193 | } |
194 | } |
195 | \endqml |
196 | |
197 | Alternatively, the \l {Settings::}{value()} and \l {Settings::}{setValue()} |
198 | functions of \l Settings can be used: |
199 | |
200 | \qml |
201 | import QtCore |
202 | import QtQuick.Controls |
203 | |
204 | ApplicationWindow { |
205 | // ... |
206 | |
207 | Component.onCompleted: splitView.restoreState(settings.value("ui/splitview")) |
208 | Component.onDestruction: settings.setValue("ui/splitview", splitView.saveState()) |
209 | |
210 | Settings { |
211 | id: settings |
212 | } |
213 | |
214 | SplitView { |
215 | id: splitView |
216 | // ... |
217 | } |
218 | } |
219 | \endqml |
220 | |
221 | \sa SplitHandle, {Customizing SplitView}, {Container Controls} |
222 | */ |
223 | |
224 | Q_LOGGING_CATEGORY(qlcQQuickSplitView, "qt.quick.controls.splitview") |
225 | Q_LOGGING_CATEGORY(qlcQQuickSplitViewPointer, "qt.quick.controls.splitview.pointer") |
226 | Q_LOGGING_CATEGORY(qlcQQuickSplitViewState, "qt.quick.controls.splitview.state") |
227 | |
228 | /* |
229 | Updates m_fillIndex to be between 0 .. (item count - 1). |
230 | */ |
231 | void QQuickSplitViewPrivate::updateFillIndex() |
232 | { |
233 | const int count = contentModel->count(); |
234 | const bool horizontal = isHorizontal(); |
235 | |
236 | qCDebug(qlcQQuickSplitView) << "looking for fillWidth/Height item amongst"<< count << "items"; |
237 | |
238 | int fillIndex = -1; |
239 | int lastVisibleIndex = -1; |
240 | for (int i = 0; i < count; ++i) { |
241 | QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index: i)); |
242 | if (!item || !item->isVisible()) |
243 | continue; |
244 | |
245 | lastVisibleIndex = i; |
246 | |
247 | const QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
248 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
249 | if (!attached) |
250 | continue; |
251 | |
252 | if ((horizontal && attached->fillWidth()) || (!horizontal && attached->fillHeight())) { |
253 | fillIndex = i; |
254 | qCDebug(qlcQQuickSplitView) << "found fillWidth/Height item at index"<< fillIndex; |
255 | break; |
256 | } |
257 | } |
258 | |
259 | if (fillIndex == -1) { |
260 | // If there was no item with fillWidth/fillHeight set, fillIndex will be -1, |
261 | // and we'll set m_fillIndex to the last visible item. |
262 | // If there was an item with fillWidth/fillHeight set, we were already done and this will be skipped. |
263 | fillIndex = lastVisibleIndex != -1 ? lastVisibleIndex : count - 1; |
264 | qCDebug(qlcQQuickSplitView) << "found no fillWidth/Height item; using last item at index"<< fillIndex; |
265 | } |
266 | // Take new fillIndex into use. |
267 | m_fillIndex = fillIndex; |
268 | } |
269 | |
270 | /* |
271 | Resizes split items according to their preferred size and any constraints. |
272 | |
273 | If a split item is being resized due to a split handle being dragged, |
274 | it will be resized accordingly. |
275 | |
276 | Items that aren't visible are skipped. |
277 | */ |
278 | void QQuickSplitViewPrivate::layoutResizeSplitItems(qreal &usedWidth, qreal &usedHeight, int &indexBeingResizedDueToDrag) |
279 | { |
280 | const int count = contentModel->count(); |
281 | const bool horizontal = isHorizontal(); |
282 | for (int index = 0; index < count; ++index) { |
283 | QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index)); |
284 | if (!item || !item->isVisible()) { |
285 | // The item is not visible, so skip it. |
286 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": split item "<< item |
287 | << " at index "<< index << " is not visible; skipping it and its handles (if any)"; |
288 | continue; |
289 | } |
290 | |
291 | const QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item); |
292 | QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
293 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
294 | const auto sizeData = effectiveSizeData(itemPrivate, attached); |
295 | |
296 | const bool resizeLeftItem = m_fillIndex > m_pressedHandleIndex; |
297 | // True if any handle is pressed. |
298 | const bool isAHandlePressed = m_pressedHandleIndex != -1; |
299 | // True if this particular item is being resized as a result of a handle being dragged. |
300 | const bool isBeingResized = isAHandlePressed && ((resizeLeftItem && index == m_pressedHandleIndex) |
301 | || (!resizeLeftItem && index == m_nextVisibleIndexAfterPressedHandle)); |
302 | if (isBeingResized) { |
303 | indexBeingResizedDueToDrag = index; |
304 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": dragging handle for item"; |
305 | } |
306 | |
307 | const qreal size = horizontal ? width : height; |
308 | qreal requestedSize = 0; |
309 | if (isBeingResized) { |
310 | // Don't let the mouse go past either edge of the SplitView. |
311 | const qreal clampedMousePos = horizontal |
312 | ? qBound(min: qreal(0.0), val: m_mousePos.x(), max: qreal(width)) |
313 | : qBound(min: qreal(0.0), val: m_mousePos.y(), max: qreal(height)); |
314 | |
315 | // We also need to ensure that the item's edge doesn't go too far |
316 | // out and hence give the item more space than is available. |
317 | const int firstIndex = resizeLeftItem ? m_nextVisibleIndexAfterPressedHandle : 0; |
318 | const int lastIndex = resizeLeftItem ? contentModel->count() - 1 : m_pressedHandleIndex; |
319 | const qreal accumulated = accumulatedSize(firstIndex, lastIndex); |
320 | |
321 | const qreal mousePosRelativeToLeftHandleEdge = horizontal |
322 | ? m_pressPos.x() - m_handlePosBeforePress.x() |
323 | : m_pressPos.y() - m_handlePosBeforePress.y(); |
324 | |
325 | const QQuickItem *pressedHandleItem = m_handleItems.at(i: m_pressedHandleIndex); |
326 | const qreal pressedHandleSize = horizontal ? pressedHandleItem->width() : pressedHandleItem->height(); |
327 | |
328 | if (resizeLeftItem) { |
329 | // The handle shouldn't cross other handles, so use the right edge of |
330 | // the first handle to the left as the left edge. |
331 | qreal leftEdge = 0; |
332 | for (int i = m_pressedHandleIndex - 1; i >= 0; --i) { |
333 | const QQuickItem *nextHandleToTheLeft = m_handleItems.at(i); |
334 | if (nextHandleToTheLeft->isVisible()) { |
335 | leftEdge = horizontal |
336 | ? nextHandleToTheLeft->x() + nextHandleToTheLeft->width() |
337 | : nextHandleToTheLeft->y() + nextHandleToTheLeft->height(); |
338 | break; |
339 | } |
340 | } |
341 | |
342 | // The mouse can be clicked anywhere in the handle, and if we don't account for |
343 | // its position within the handle, the handle will jump when dragged. |
344 | const qreal pressedHandlePos = clampedMousePos - mousePosRelativeToLeftHandleEdge; |
345 | |
346 | const qreal rightStop = size - accumulated - pressedHandleSize; |
347 | qreal leftStop = qMax(a: leftEdge, b: pressedHandlePos); |
348 | // qBound() doesn't care if min is greater than max, but we do. |
349 | if (leftStop > rightStop) |
350 | leftStop = rightStop; |
351 | const qreal newHandlePos = qBound(min: leftStop, val: pressedHandlePos, max: rightStop); |
352 | const qreal newItemSize = newHandlePos - leftEdge; |
353 | |
354 | // We still need to use requestedSize in the width/height call below, |
355 | // because sizeData has already been calculated and now contains an old |
356 | // effectivePreferredWidth/Height value. |
357 | requestedSize = newItemSize; |
358 | |
359 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": resized (dragged) "<< item |
360 | << " (clampedMousePos="<< clampedMousePos |
361 | << " pressedHandlePos="<< pressedHandlePos |
362 | << " accumulated="<< accumulated |
363 | << " leftEdge="<< leftEdge |
364 | << " leftStop="<< leftStop |
365 | << " rightStop="<< rightStop |
366 | << " newHandlePos="<< newHandlePos |
367 | << " newItemSize="<< newItemSize << ")"; |
368 | } else { // Resizing the item on the right. |
369 | // The handle shouldn't cross other handles, so use the left edge of |
370 | // the first handle to the right as the right edge. |
371 | qreal rightEdge = size; |
372 | if (m_nextVisibleIndexAfterPressedHandle < m_handleItems.size()) { |
373 | const QQuickItem *rightHandle = m_handleItems.at(i: m_nextVisibleIndexAfterPressedHandle); |
374 | rightEdge = horizontal ? rightHandle->x() : rightHandle->y(); |
375 | } |
376 | |
377 | // The mouse can be clicked anywhere in the handle, and if we don't account for |
378 | // its position within the handle, the handle will jump when dragged. |
379 | const qreal pressedHandlePos = clampedMousePos - mousePosRelativeToLeftHandleEdge; |
380 | |
381 | const qreal leftStop = accumulated - pressedHandleSize; |
382 | qreal rightStop = qMin(a: rightEdge - pressedHandleSize, b: pressedHandlePos); |
383 | // qBound() doesn't care if min is greater than max, but we do. |
384 | if (rightStop < leftStop) |
385 | rightStop = leftStop; |
386 | const qreal newHandlePos = qBound(min: leftStop, val: pressedHandlePos, max: rightStop); |
387 | const qreal newItemSize = rightEdge - (newHandlePos + pressedHandleSize); |
388 | |
389 | // We still need to use requestedSize in the width/height call below, |
390 | // because sizeData has already been calculated and now contains an old |
391 | // effectivePreferredWidth/Height value. |
392 | requestedSize = newItemSize; |
393 | |
394 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": resized (dragged) "<< item |
395 | << " (clampedMousePos="<< clampedMousePos |
396 | << " pressedHandlePos="<< pressedHandlePos |
397 | << " accumulated="<< accumulated |
398 | << " leftEdge="<< rightEdge |
399 | << " leftStop="<< leftStop |
400 | << " rightStop="<< rightStop |
401 | << " newHandlePos="<< newHandlePos |
402 | << " newItemSize="<< newItemSize << ")"; |
403 | } |
404 | } else if (index != m_fillIndex) { |
405 | // No handle is being dragged and we're not the fill item, |
406 | // so set our preferred size as we normally would. |
407 | requestedSize = horizontal |
408 | ? sizeData.effectivePreferredWidth : sizeData.effectivePreferredHeight; |
409 | } |
410 | |
411 | if (index != m_fillIndex) { |
412 | LayoutData layoutData; |
413 | if (horizontal) { |
414 | layoutData.width = qBound( |
415 | min: sizeData.effectiveMinimumWidth, |
416 | val: requestedSize, |
417 | max: sizeData.effectiveMaximumWidth); |
418 | layoutData.height = height; |
419 | } else { |
420 | layoutData.width = width; |
421 | layoutData.height = qBound( |
422 | min: sizeData.effectiveMinimumHeight, |
423 | val: requestedSize, |
424 | max: sizeData.effectiveMaximumHeight); |
425 | } |
426 | |
427 | // Mark that this item has been manually resized. After this |
428 | // we can override the preferredWidth & preferredHeight |
429 | if (isBeingResized) |
430 | layoutData.wasResizedByHandle = true; |
431 | |
432 | m_layoutData.insert(key: item, value: layoutData); |
433 | |
434 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": calculated the following size data for split item "<< item |
435 | << ": eminW="<< sizeData.effectiveMinimumWidth |
436 | << ", eminH="<< sizeData.effectiveMinimumHeight |
437 | << ", eprfW="<< sizeData.effectivePreferredWidth |
438 | << ", eprfH="<< sizeData.effectivePreferredHeight |
439 | << ", emaxW="<< sizeData.effectiveMaximumWidth |
440 | << ", emaxH="<< sizeData.effectiveMaximumHeight |
441 | << ", w="<< layoutData.width |
442 | << ", h="<< layoutData.height << ""; |
443 | |
444 | // Keep track of how much space has been used so far. |
445 | if (horizontal) |
446 | usedWidth += layoutData.width; |
447 | else |
448 | usedHeight += layoutData.height; |
449 | } else if (indexBeingResizedDueToDrag != m_fillIndex) { |
450 | // The fill item is resized afterwards, outside of the loop. |
451 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": skipping fill item as we resize it last"; |
452 | } |
453 | |
454 | // Also account for the size of the handle for this item (if any). |
455 | // We do this for the fill item too, which is why it's outside of the check above. |
456 | if (index < count - 1 && m_handle) { |
457 | QQuickItem *handleItem = m_handleItems.at(i: index); |
458 | // The handle for an item that's not visible will usually already be skipped |
459 | // with the item visibility check higher up, but if the view looks like this |
460 | // [ visible ] | [ visible (fill) ] | [ hidden ] |
461 | // ^ |
462 | // hidden |
463 | // and we're iterating over the second item (which is visible but has no handle), |
464 | // we need to add an extra check for it to avoid it still taking up space. |
465 | if (handleItem->isVisible()) { |
466 | if (horizontal) { |
467 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index |
468 | << ": handle takes up "<< handleItem->width() << " width"; |
469 | usedWidth += handleItem->width(); |
470 | } else { |
471 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index |
472 | << ": handle takes up "<< handleItem->height() << " height"; |
473 | usedHeight += handleItem->height(); |
474 | } |
475 | } else { |
476 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": handle is not visible; skipping it"; |
477 | } |
478 | } |
479 | } |
480 | } |
481 | |
482 | /* |
483 | Resizes the fill item by giving it the remaining space |
484 | after all other items have been resized. |
485 | |
486 | Items that aren't visible are skipped. |
487 | */ |
488 | void QQuickSplitViewPrivate::layoutResizeFillItem(QQuickItem *fillItem, |
489 | qreal &usedWidth, qreal &usedHeight, int indexBeingResizedDueToDrag) |
490 | { |
491 | // Only bother resizing if it it's visible. Also, if it's being resized due to a drag, |
492 | // then we've already set its size in layoutResizeSplitItems(), so no need to do it here. |
493 | if (!fillItem || !fillItem->isVisible() || indexBeingResizedDueToDrag == m_fillIndex) { |
494 | qCDebug(qlcQQuickSplitView).nospace() << m_fillIndex << ": - fill item "<< fillItem |
495 | << " is not visible or was already resized due to a drag;" |
496 | << " skipping it and its handles (if any)"; |
497 | return; |
498 | } |
499 | |
500 | const QQuickItemPrivate *fillItemPrivate = QQuickItemPrivate::get(item: fillItem); |
501 | const QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
502 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: fillItem, create: false)); |
503 | const auto fillSizeData = effectiveSizeData(itemPrivate: fillItemPrivate, attached); |
504 | |
505 | LayoutData layoutData; |
506 | if (isHorizontal()) { |
507 | layoutData.width = qBound( |
508 | min: fillSizeData.effectiveMinimumWidth, |
509 | val: width - usedWidth, |
510 | max: fillSizeData.effectiveMaximumWidth); |
511 | layoutData.height = height; |
512 | usedWidth += layoutData.width; |
513 | } else { |
514 | layoutData.width = width; |
515 | layoutData.height = qBound( |
516 | min: fillSizeData.effectiveMinimumHeight, |
517 | val: height - usedHeight, |
518 | max: fillSizeData.effectiveMaximumHeight); |
519 | usedHeight += layoutData.height; |
520 | } |
521 | |
522 | m_layoutData.insert(key: fillItem, value: layoutData); |
523 | |
524 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< m_fillIndex |
525 | << ": resized split fill item "<< fillItem << " (effective" |
526 | << " minW="<< fillSizeData.effectiveMinimumWidth |
527 | << ", minH="<< fillSizeData.effectiveMinimumHeight |
528 | << ", maxW="<< fillSizeData.effectiveMaximumWidth |
529 | << ", maxH="<< fillSizeData.effectiveMaximumHeight << ")"; |
530 | } |
531 | |
532 | /* |
533 | Limit the sizes if needed and apply them into items. |
534 | */ |
535 | void QQuickSplitViewPrivate::limitAndApplySizes(qreal usedWidth, qreal usedHeight) |
536 | { |
537 | const int count = contentModel->count(); |
538 | const bool horizontal = isHorizontal(); |
539 | |
540 | const qreal maxSize = horizontal ? width : height; |
541 | const qreal usedSize = horizontal ? usedWidth : usedHeight; |
542 | if (usedSize > maxSize) { |
543 | qCDebug(qlcQQuickSplitView).nospace() << "usedSize "<< usedSize << " is greater than maxSize " |
544 | << maxSize << "; reducing size of non-filled items from right to left / bottom to top"; |
545 | |
546 | // If items don't fit, reduce the size of non-filled items from |
547 | // right to left / bottom to top. At this point filled item is |
548 | // already at its minimum size or usedSize wouldn't be > maxSize. |
549 | qreal delta = usedSize - maxSize; |
550 | for (int index = count - 1; index >= 0; --index) { |
551 | if (index == m_fillIndex) |
552 | continue; |
553 | QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index)); |
554 | if (!item || !item->isVisible()) |
555 | continue; |
556 | |
557 | const QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item); |
558 | QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
559 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
560 | const auto sizeData = effectiveSizeData(itemPrivate, attached); |
561 | const qreal maxReduce = horizontal ? |
562 | m_layoutData[item].width - sizeData.effectiveMinimumWidth : |
563 | m_layoutData[item].height - sizeData.effectiveMinimumHeight; |
564 | |
565 | const qreal reduce = std::min(a: maxReduce, b: delta); |
566 | if (horizontal) |
567 | m_layoutData[item].width -= reduce; |
568 | else |
569 | m_layoutData[item].height -= reduce; |
570 | |
571 | delta -= reduce; |
572 | if (delta <= 0) { |
573 | // Now all the items fit, so continue |
574 | break; |
575 | } |
576 | } |
577 | } |
578 | |
579 | qCDebug(qlcQQuickSplitView).nospace() << " applying new sizes to "<< count << " items (excluding hidden items)"; |
580 | |
581 | // Apply the new sizes into items |
582 | for (int index = 0; index < count; ++index) { |
583 | QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index)); |
584 | if (!item || !item->isVisible()) |
585 | continue; |
586 | |
587 | QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
588 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
589 | LayoutData layoutData = m_layoutData.value(key: item); |
590 | if (layoutData.wasResizedByHandle) { |
591 | // Modify the preferredWidth/Height, otherwise the original implicit/preferred size |
592 | // will be used on the next layout (when it's no longer being resized). |
593 | if (!attached) { |
594 | // Force the attached object to be created since we rely on it. |
595 | attached = qobject_cast<QQuickSplitViewAttached*>( |
596 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: true)); |
597 | } |
598 | /* |
599 | Users could conceivably respond to size changes in items by setting attached |
600 | SplitView properties: |
601 | |
602 | onWidthChanged: if (width < 10) secondItem.SplitView.preferredWidth = 100 |
603 | |
604 | We handle this by doing another layout after the current layout if the |
605 | attached/implicit size properties are set during this layout. However, we also |
606 | need to set preferredWidth/Height here, otherwise the original implicit/preferred sizes |
607 | will be used on the next layout (when it's no longer being resized). |
608 | But we don't want this to count as a request for a delayed layout, so we guard against it. |
609 | */ |
610 | m_ignoreNextLayoutRequest = true; |
611 | if (horizontal) |
612 | attached->setPreferredWidth(layoutData.width); |
613 | else |
614 | attached->setPreferredHeight(layoutData.height); |
615 | } |
616 | |
617 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< index << ": resized item "<< item << " from " |
618 | << item->width() << "x"<< item->height() << " to " |
619 | << layoutData.width << "x"<< layoutData.height; |
620 | |
621 | item->setWidth(layoutData.width); |
622 | item->setHeight(layoutData.height); |
623 | } |
624 | } |
625 | |
626 | /* |
627 | Positions items by laying them out in a row or column. |
628 | |
629 | Items that aren't visible are skipped. |
630 | */ |
631 | void QQuickSplitViewPrivate::layoutPositionItems(const QQuickItem *fillItem) |
632 | { |
633 | const bool horizontal = isHorizontal(); |
634 | const int count = contentModel->count(); |
635 | qreal usedWidth = 0; |
636 | qreal usedHeight = 0; |
637 | |
638 | for (int i = 0; i < count; ++i) { |
639 | QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index: i)); |
640 | if (!item || !item->isVisible()) { |
641 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< i << ": split item "<< item |
642 | << " is not visible; skipping it and its handles (if any)"; |
643 | continue; |
644 | } |
645 | |
646 | // Position the item. |
647 | if (horizontal) { |
648 | item->setX(usedWidth); |
649 | item->setY(0); |
650 | } else { |
651 | item->setX(0); |
652 | item->setY(usedHeight); |
653 | } |
654 | |
655 | // Keep track of how much space has been used so far. |
656 | if (horizontal) |
657 | usedWidth += item->width(); |
658 | else |
659 | usedHeight += item->height(); |
660 | |
661 | if (Q_UNLIKELY(qlcQQuickSplitView().isDebugEnabled() && fillItem)) { |
662 | const QQuickItemPrivate *fillItemPrivate = QQuickItemPrivate::get(item: fillItem); |
663 | const QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
664 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: fillItem, create: false)); |
665 | const auto sizeData = effectiveSizeData(itemPrivate: fillItemPrivate, attached); |
666 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< i << ": positioned " |
667 | << (i == m_fillIndex ? "fill item ": "item ") << item << " (effective" |
668 | << " minW="<< sizeData.effectiveMinimumWidth |
669 | << ", minH="<< sizeData.effectiveMinimumHeight |
670 | << ", prfW="<< sizeData.effectivePreferredWidth |
671 | << ", prfH="<< sizeData.effectivePreferredHeight |
672 | << ", maxW="<< sizeData.effectiveMaximumWidth |
673 | << ", maxH="<< sizeData.effectiveMaximumHeight << ")"; |
674 | } |
675 | |
676 | // Position the handle for this item (if any). |
677 | if (i < count - 1 && m_handle) { |
678 | // Position the handle. |
679 | QQuickItem *handleItem = m_handleItems.at(i); |
680 | handleItem->setX(horizontal ? usedWidth : 0); |
681 | handleItem->setY(horizontal ? 0 : usedHeight); |
682 | |
683 | if (horizontal) |
684 | usedWidth += handleItem->width(); |
685 | else |
686 | usedHeight += handleItem->height(); |
687 | |
688 | qCDebug(qlcQQuickSplitView).nospace() << " - "<< i << ": positioned handle "<< handleItem; |
689 | } |
690 | } |
691 | } |
692 | |
693 | void QQuickSplitViewPrivate::requestLayout() |
694 | { |
695 | Q_Q(QQuickSplitView); |
696 | q->polish(); |
697 | } |
698 | |
699 | /* |
700 | Layout steps are (horizontal SplitView as an example): |
701 | 1) layoutResizeSplitItems: Gives each non-filled item its preferredWidth |
702 | or if not set, implicitWidth. Sizes are kept between effectiveMinimumWidth |
703 | and effectiveMaximumWidth and stored into layoutData for now. |
704 | 2) layoutResizeFillItem: Gives filled item all the remaining space. Size is |
705 | kept between effectiveMinimumWidth and effectiveMaximumWidth and stored |
706 | into layoutData for now. |
707 | 3) limitAndApplySizes: If we have used more space than SplitView item has, |
708 | start reducing non-filled item sizes from right-to-left. Reduce them up |
709 | to minimumWidth or until SplitView item width is reached. Finally set the |
710 | new item sizes from layoutData. |
711 | */ |
712 | void QQuickSplitViewPrivate::layout() |
713 | { |
714 | if (!componentComplete) |
715 | return; |
716 | |
717 | if (m_layingOut) |
718 | return; |
719 | |
720 | const int count = contentModel->count(); |
721 | if (count <= 0) |
722 | return; |
723 | |
724 | Q_ASSERT_X(m_fillIndex < count, Q_FUNC_INFO, qPrintable( |
725 | QString::fromLatin1("m_fillIndex is %1 but our count is %2").arg(m_fillIndex).arg(count))); |
726 | |
727 | Q_ASSERT_X(!m_handle || m_handleItems.size() == count - 1, Q_FUNC_INFO, qPrintable(QString::fromLatin1( |
728 | "Expected %1 handle items, but there are %2").arg(count - 1).arg(m_handleItems.size()))); |
729 | |
730 | // We allow mouse events to instantly trigger layouts, whereas with e.g. |
731 | // attached properties being set, we require a delayed layout. |
732 | // To prevent recursive calls during mouse events, we need this guard. |
733 | QBoolBlocker guard(m_layingOut, true); |
734 | |
735 | const bool horizontal = isHorizontal(); |
736 | qCDebug(qlcQQuickSplitView) << "laying out"<< count << "split items" |
737 | << (horizontal ? "horizontally": "vertically") << "in SplitView"<< q_func(); |
738 | |
739 | // Total sizes of items used during the layout operation. |
740 | qreal usedWidth = 0; |
741 | qreal usedHeight = 0; |
742 | int indexBeingResizedDueToDrag = -1; |
743 | m_layoutData.clear(); |
744 | |
745 | qCDebug(qlcQQuickSplitView) << " resizing:"; |
746 | |
747 | // First, resize the non-filled items. We need to do this first because otherwise fill |
748 | // items would take up all of the remaining space as soon as they are encountered. |
749 | layoutResizeSplitItems(usedWidth, usedHeight, indexBeingResizedDueToDrag); |
750 | |
751 | qCDebug(qlcQQuickSplitView).nospace() |
752 | << " - (remaining width="<< width - usedWidth |
753 | << " remaining height="<< height - usedHeight << ")"; |
754 | |
755 | // Give the fill item the remaining space. |
756 | QQuickItem *fillItem = qobject_cast<QQuickItem*>(o: contentModel->object(index: m_fillIndex)); |
757 | layoutResizeFillItem(fillItem, usedWidth, usedHeight, indexBeingResizedDueToDrag); |
758 | |
759 | // Reduce the sizes still if needed and apply them into items. |
760 | limitAndApplySizes(usedWidth, usedHeight); |
761 | |
762 | qCDebug(qlcQQuickSplitView) << " positioning:"; |
763 | |
764 | // Position the items. |
765 | layoutPositionItems(fillItem); |
766 | |
767 | qCDebug(qlcQQuickSplitView).nospace() << "finished layouting"; |
768 | } |
769 | |
770 | void QQuickSplitViewPrivate::createHandles() |
771 | { |
772 | Q_ASSERT(m_handle); |
773 | // A handle only makes sense if there are two items on either side. |
774 | if (contentModel->count() <= 1) |
775 | return; |
776 | |
777 | // Create new handle items if there aren't enough. |
778 | const int count = contentModel->count() - 1; |
779 | qCDebug(qlcQQuickSplitView) << "creating"<< count << "handles"; |
780 | m_handleItems.reserve(size: count); |
781 | for (int i = 0; i < count; ++i) |
782 | createHandleItem(index: i); |
783 | } |
784 | |
785 | void QQuickSplitViewPrivate::createHandleItem(int index) |
786 | { |
787 | Q_Q(QQuickSplitView); |
788 | if (contentModel->count() <= 1) |
789 | return; |
790 | |
791 | qCDebug(qlcQQuickSplitView) << "- creating handle for split item at index"<< index |
792 | << "from handle component"<< m_handle; |
793 | |
794 | // If we don't use the correct context, it won't be possible to refer to |
795 | // the control's id from within the delegate. |
796 | QQmlContext *context = m_handle->creationContext(); |
797 | // The component might not have been created in QML, in which case |
798 | // the creation context will be null and we have to create it ourselves. |
799 | if (!context) |
800 | context = qmlContext(q); |
801 | QQuickItem *handleItem = qobject_cast<QQuickItem*>(o: m_handle->beginCreate(context)); |
802 | if (handleItem) { |
803 | handleItem->setParent(q); |
804 | qCDebug(qlcQQuickSplitView) << "- successfully created handle item"<< handleItem << "for split item at index"<< index; |
805 | |
806 | // Insert the item to our list of items *before* its parent is set to us, |
807 | // so that we can avoid it being added as a content item by checking |
808 | // if it is in the list in isContent(). |
809 | m_handleItems.insert(i: index, t: handleItem); |
810 | |
811 | handleItem->setParentItem(q); |
812 | // Handles must have priority for press events, so we need to set this. |
813 | handleItem->setAcceptedMouseButtons(Qt::LeftButton); |
814 | handleItem->setKeepMouseGrab(true); |
815 | #if QT_CONFIG(cursor) |
816 | updateCursorHandle(handleItem); |
817 | #endif |
818 | m_handle->completeCreate(); |
819 | resizeHandle(handleItem); |
820 | } |
821 | } |
822 | |
823 | void QQuickSplitViewPrivate::removeExcessHandles() |
824 | { |
825 | int excess = m_handleItems.size() - qMax(a: 0, b: contentModel->count() - 1); |
826 | qCDebug(qlcQQuickSplitView) << "removing"<< excess << "excess handles from the end of our list"; |
827 | for (; excess > 0; --excess) { |
828 | QQuickItem *handleItem = m_handleItems.takeLast(); |
829 | delete handleItem; |
830 | } |
831 | } |
832 | |
833 | qreal QQuickSplitViewPrivate::accumulatedSize(int firstIndex, int lastIndex) const |
834 | { |
835 | qreal size = 0.0; |
836 | const bool horizontal = isHorizontal(); |
837 | for (int i = firstIndex; i <= lastIndex; ++i) { |
838 | QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index: i)); |
839 | if (item && item->isVisible()) { |
840 | if (i != m_fillIndex) { |
841 | size += horizontal ? item->width() : item->height(); |
842 | } else { |
843 | // If the fill item has a minimum size specified, we must respect it. |
844 | const QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
845 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
846 | if (attached) { |
847 | const QQuickSplitViewAttachedPrivate *attachedPrivate |
848 | = QQuickSplitViewAttachedPrivate::get(attached); |
849 | if (horizontal && attachedPrivate->m_isMinimumWidthSet) |
850 | size += attachedPrivate->m_minimumWidth; |
851 | else if (!horizontal && attachedPrivate->m_isMinimumHeightSet) |
852 | size += attachedPrivate->m_minimumHeight; |
853 | } |
854 | } |
855 | } |
856 | |
857 | // Only add the handle's width if there's actually a handle for this split item index. |
858 | if (i < lastIndex || lastIndex < contentModel->count() - 1) { |
859 | const QQuickItem *handleItem = m_handleItems.at(i); |
860 | if (handleItem->isVisible()) |
861 | size += horizontal ? handleItem->width() : handleItem->height(); |
862 | } |
863 | } |
864 | return size; |
865 | } |
866 | |
867 | qreal effectiveMinimumWidth(const QQuickSplitViewAttachedPrivate *attachedPrivate) |
868 | { |
869 | return attachedPrivate && attachedPrivate->m_isMinimumWidthSet ? attachedPrivate->m_minimumWidth : 0; |
870 | } |
871 | |
872 | qreal effectiveMinimumHeight(const QQuickSplitViewAttachedPrivate *attachedPrivate) |
873 | { |
874 | return attachedPrivate && attachedPrivate->m_isMinimumHeightSet ? attachedPrivate->m_minimumHeight : 0; |
875 | } |
876 | |
877 | qreal effectivePreferredWidth(const QQuickSplitViewAttachedPrivate *attachedPrivate, |
878 | const QQuickItemPrivate *itemPrivate) |
879 | { |
880 | return attachedPrivate && attachedPrivate->m_isPreferredWidthSet |
881 | ? attachedPrivate->m_preferredWidth : itemPrivate->implicitWidth; |
882 | } |
883 | |
884 | qreal effectivePreferredHeight(const QQuickSplitViewAttachedPrivate *attachedPrivate, |
885 | const QQuickItemPrivate *itemPrivate) |
886 | { |
887 | return attachedPrivate && attachedPrivate->m_isPreferredHeightSet |
888 | ? attachedPrivate->m_preferredHeight : itemPrivate->implicitHeight; |
889 | } |
890 | |
891 | qreal effectiveMaximumWidth(const QQuickSplitViewAttachedPrivate *attachedPrivate) |
892 | { |
893 | return attachedPrivate && attachedPrivate->m_isMaximumWidthSet |
894 | ? attachedPrivate->m_maximumWidth : std::numeric_limits<qreal>::infinity(); |
895 | } |
896 | |
897 | qreal effectiveMaximumHeight(const QQuickSplitViewAttachedPrivate *attachedPrivate) |
898 | { |
899 | return attachedPrivate && attachedPrivate->m_isMaximumHeightSet |
900 | ? attachedPrivate->m_maximumHeight : std::numeric_limits<qreal>::infinity(); |
901 | } |
902 | |
903 | // We don't just take an index, because the item and attached properties object |
904 | // will both be used outside of this function by calling code, so save some |
905 | // time by not accessing them twice. |
906 | QQuickSplitViewPrivate::EffectiveSizeData QQuickSplitViewPrivate::effectiveSizeData( |
907 | const QQuickItemPrivate *itemPrivate, const QQuickSplitViewAttached *attached) const |
908 | { |
909 | EffectiveSizeData data; |
910 | const QQuickSplitViewAttachedPrivate *attachedPrivate = attached ? QQuickSplitViewAttachedPrivate::get(attached) : nullptr; |
911 | data.effectiveMinimumWidth = effectiveMinimumWidth(attachedPrivate); |
912 | data.effectiveMinimumHeight = effectiveMinimumHeight(attachedPrivate); |
913 | data.effectivePreferredWidth = effectivePreferredWidth(attachedPrivate, itemPrivate); |
914 | data.effectivePreferredHeight = effectivePreferredHeight(attachedPrivate, itemPrivate); |
915 | data.effectiveMaximumWidth = effectiveMaximumWidth(attachedPrivate); |
916 | data.effectiveMaximumHeight = effectiveMaximumHeight(attachedPrivate); |
917 | return data; |
918 | } |
919 | |
920 | int QQuickSplitViewPrivate::handleIndexForSplitIndex(int splitIndex) const |
921 | { |
922 | // If it's the first and only item in the view, it doesn't have a handle, |
923 | // so return -1: splitIndex (0) - 1. |
924 | // If it's the last item in the view, it doesn't have a handle, so use |
925 | // the handle for the previous item. |
926 | return splitIndex == contentModel->count() - 1 ? splitIndex - 1 : splitIndex; |
927 | } |
928 | |
929 | void QQuickSplitViewPrivate::destroyHandles() |
930 | { |
931 | qCDebug(qlcQQuickSplitView) << "destroying"<< m_handleItems.size() << "handles"; |
932 | qDeleteAll(c: m_handleItems); |
933 | m_handleItems.clear(); |
934 | } |
935 | |
936 | void QQuickSplitViewPrivate::resizeHandle(QQuickItem *handleItem) |
937 | { |
938 | const bool horizontal = isHorizontal(); |
939 | handleItem->setWidth(horizontal ? handleItem->implicitWidth() : width); |
940 | handleItem->setHeight(horizontal ? height : handleItem->implicitHeight()); |
941 | } |
942 | |
943 | void QQuickSplitViewPrivate::resizeHandles() |
944 | { |
945 | for (QQuickItem *handleItem : m_handleItems) |
946 | resizeHandle(handleItem); |
947 | } |
948 | |
949 | #if QT_CONFIG(cursor) |
950 | void QQuickSplitViewPrivate::updateCursorHandle(QQuickItem *handleItem) |
951 | { |
952 | handleItem->setCursor(isHorizontal() ? Qt::SplitHCursor : Qt::SplitVCursor); |
953 | } |
954 | #endif |
955 | |
956 | void QQuickSplitViewPrivate::updateHandleVisibilities() |
957 | { |
958 | // If this is the first item that is visible, we won't have any |
959 | // handles yet, because we don't create a handle if we only have one item. |
960 | if (m_handleItems.isEmpty()) |
961 | return; |
962 | |
963 | // If the visibility/children change makes any item the last (right/bottom-most) |
964 | // visible item, we don't want to display a handle for it either: |
965 | // [ visible (fill) ] | [ hidden ] | [ hidden ] |
966 | // ^ ^ |
967 | // hidden hidden |
968 | const int count = contentModel->count(); |
969 | int lastVisibleItemIndex = -1; |
970 | for (int i = count - 1; i >= 0; --i) { |
971 | const QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index: i)); |
972 | if (item && item->isVisible()) { |
973 | lastVisibleItemIndex = i; |
974 | break; |
975 | } |
976 | } |
977 | |
978 | for (int i = 0; i < count - 1; ++i) { |
979 | const QQuickItem *item = qobject_cast<QQuickItem*>(o: contentModel->object(index: i)); |
980 | QQuickItem *handleItem = m_handleItems.at(i); |
981 | if (i != lastVisibleItemIndex) |
982 | handleItem->setVisible(item && item->isVisible()); |
983 | else |
984 | handleItem->setVisible(false); |
985 | qCDebug(qlcQQuickSplitView) << "set visible property of handle"<< handleItem << "at index" |
986 | << i << "to"<< handleItem->isVisible(); |
987 | } |
988 | } |
989 | |
990 | void QQuickSplitViewPrivate::updateHoveredHandle(QQuickItem *hoveredItem) |
991 | { |
992 | qCDebug(qlcQQuickSplitViewPointer) << "updating hovered handle after"<< hoveredItem << "was hovered"; |
993 | |
994 | const int oldHoveredHandleIndex = m_hoveredHandleIndex; |
995 | m_hoveredHandleIndex = m_handleItems.indexOf(t: hoveredItem); |
996 | if (m_hoveredHandleIndex == oldHoveredHandleIndex) |
997 | return; |
998 | |
999 | // First, clear the hovered flag of any previously-hovered handle. |
1000 | if (oldHoveredHandleIndex != -1) { |
1001 | QQuickItem *oldHoveredHandle = m_handleItems.at(i: oldHoveredHandleIndex); |
1002 | QQuickSplitHandleAttached *oldHoveredHandleAttached = qobject_cast<QQuickSplitHandleAttached*>( |
1003 | object: qmlAttachedPropertiesObject<QQuickSplitHandleAttached>(obj: oldHoveredHandle, create: true)); |
1004 | QQuickSplitHandleAttachedPrivate::get(attached: oldHoveredHandleAttached)->setHovered(false); |
1005 | qCDebug(qlcQQuickSplitViewPointer) << "handle item at index"<< oldHoveredHandleIndex << "is no longer hovered"; |
1006 | } |
1007 | |
1008 | if (m_hoveredHandleIndex != -1) { |
1009 | QQuickSplitHandleAttached *handleAttached = qobject_cast<QQuickSplitHandleAttached*>( |
1010 | object: qmlAttachedPropertiesObject<QQuickSplitHandleAttached>(obj: hoveredItem, create: true)); |
1011 | QQuickSplitHandleAttachedPrivate::get(attached: handleAttached)->setHovered(true); |
1012 | qCDebug(qlcQQuickSplitViewPointer) << "handle item at index"<< m_hoveredHandleIndex << "is now hovered"; |
1013 | } else { |
1014 | qCDebug(qlcQQuickSplitViewPointer) << "either there is no hovered item or"<< hoveredItem << "is not a handle"; |
1015 | } |
1016 | } |
1017 | |
1018 | void QQuickSplitViewPrivate::setResizing(bool resizing) |
1019 | { |
1020 | Q_Q(QQuickSplitView); |
1021 | if (resizing == m_resizing) |
1022 | return; |
1023 | |
1024 | m_resizing = resizing; |
1025 | emit q->resizingChanged(); |
1026 | } |
1027 | |
1028 | bool QQuickSplitViewPrivate::isHorizontal() const |
1029 | { |
1030 | return m_orientation == Qt::Horizontal; |
1031 | } |
1032 | |
1033 | QQuickItem *QQuickSplitViewPrivate::getContentItem() |
1034 | { |
1035 | Q_Q(QQuickSplitView); |
1036 | if (QQuickItem *item = QQuickContainerPrivate::getContentItem()) |
1037 | return item; |
1038 | |
1039 | return new QQuickContentItem(q); |
1040 | } |
1041 | |
1042 | bool QQuickSplitViewPrivate::handlePress(const QPointF &point, ulong timestamp) |
1043 | { |
1044 | Q_Q(QQuickSplitView); |
1045 | QQuickContainerPrivate::handlePress(point, timestamp); |
1046 | |
1047 | QQuickItem *pressedItem = q->childAt(x: point.x(), y: point.y()); |
1048 | const int pressedHandleIndex = m_handleItems.indexOf(t: pressedItem); |
1049 | if (pressedHandleIndex != -1) { |
1050 | m_pressedHandleIndex = pressedHandleIndex; |
1051 | m_pressPos = point; |
1052 | m_mousePos = point; |
1053 | |
1054 | const QQuickItem *leftOrTopItem = qobject_cast<QQuickItem*>(o: contentModel->object(index: m_pressedHandleIndex)); |
1055 | // Find the first item to the right/bottom of this one that is visible. |
1056 | QQuickItem *rightOrBottomItem = nullptr; |
1057 | m_nextVisibleIndexAfterPressedHandle = -1; |
1058 | for (int i = m_pressedHandleIndex + 1; i < contentModel->count(); ++i) { |
1059 | auto nextItem = qobject_cast<QQuickItem*>(o: contentModel->object(index: i)); |
1060 | if (nextItem && nextItem->isVisible()) { |
1061 | rightOrBottomItem = nextItem; |
1062 | m_nextVisibleIndexAfterPressedHandle = i; |
1063 | break; |
1064 | } |
1065 | } |
1066 | Q_ASSERT_X(rightOrBottomItem, Q_FUNC_INFO, qPrintable(QString::fromLatin1( |
1067 | "Failed to find a visible item to the right/bottom of the one that was pressed at index %1; this shouldn't happen") |
1068 | .arg(m_pressedHandleIndex))); |
1069 | |
1070 | const bool isHorizontal = m_orientation == Qt::Horizontal; |
1071 | if (leftOrTopItem) { |
1072 | m_leftOrTopItemSizeBeforePress = isHorizontal |
1073 | ? leftOrTopItem->width() |
1074 | : leftOrTopItem->height(); |
1075 | } |
1076 | m_rightOrBottomItemSizeBeforePress = isHorizontal ? rightOrBottomItem->width() : rightOrBottomItem->height(); |
1077 | m_handlePosBeforePress = pressedItem->position(); |
1078 | |
1079 | |
1080 | // Force the attached object to be created since we rely on it. |
1081 | QQuickSplitHandleAttached *handleAttached = qobject_cast<QQuickSplitHandleAttached*>( |
1082 | object: qmlAttachedPropertiesObject<QQuickSplitHandleAttached>(obj: pressedItem, create: true)); |
1083 | QQuickSplitHandleAttachedPrivate::get(attached: handleAttached)->setPressed(true); |
1084 | |
1085 | setResizing(true); |
1086 | |
1087 | qCDebug(qlcQQuickSplitViewPointer).nospace() << "handled press -" |
1088 | << " left/top index="<< m_pressedHandleIndex << "," |
1089 | << " size before press="<< m_leftOrTopItemSizeBeforePress << "," |
1090 | << " item="<< leftOrTopItem |
1091 | << " right/bottom index="<< m_nextVisibleIndexAfterPressedHandle << "," |
1092 | << " size before press="<< m_rightOrBottomItemSizeBeforePress |
1093 | << " item="<< rightOrBottomItem; |
1094 | } |
1095 | return true; |
1096 | } |
1097 | |
1098 | bool QQuickSplitViewPrivate::handleMove(const QPointF &point, ulong timestamp) |
1099 | { |
1100 | QQuickContainerPrivate::handleMove(point, timestamp); |
1101 | |
1102 | if (m_pressedHandleIndex != -1) { |
1103 | m_mousePos = point; |
1104 | // Don't request layouts for input events because we want |
1105 | // resizing to be as responsive and smooth as possible. |
1106 | updatePolish(); |
1107 | } |
1108 | return true; |
1109 | } |
1110 | |
1111 | bool QQuickSplitViewPrivate::handleRelease(const QPointF &point, ulong timestamp) |
1112 | { |
1113 | QQuickContainerPrivate::handleRelease(point, timestamp); |
1114 | |
1115 | if (m_pressedHandleIndex != -1) { |
1116 | QQuickItem *pressedHandle = m_handleItems.at(i: m_pressedHandleIndex); |
1117 | QQuickSplitHandleAttached *handleAttached = qobject_cast<QQuickSplitHandleAttached*>( |
1118 | object: qmlAttachedPropertiesObject<QQuickSplitHandleAttached>(obj: pressedHandle, create: true)); |
1119 | QQuickSplitHandleAttachedPrivate::get(attached: handleAttached)->setPressed(false); |
1120 | } |
1121 | |
1122 | setResizing(false); |
1123 | |
1124 | m_pressedHandleIndex = -1; |
1125 | m_pressPos = QPointF(); |
1126 | m_mousePos = QPointF(); |
1127 | m_handlePosBeforePress = QPointF(); |
1128 | m_leftOrTopItemSizeBeforePress = 0.0; |
1129 | m_rightOrBottomItemSizeBeforePress = 0.0; |
1130 | return true; |
1131 | } |
1132 | |
1133 | void QQuickSplitViewPrivate::itemVisibilityChanged(QQuickItem *item) |
1134 | { |
1135 | const int itemIndex = contentModel->indexOf(object: item, objectContext: nullptr); |
1136 | Q_ASSERT(itemIndex != -1); |
1137 | |
1138 | qCDebug(qlcQQuickSplitView) << "visible property of split item" |
1139 | << item << "at index"<< itemIndex << "changed to"<< item->isVisible(); |
1140 | |
1141 | // The visibility of an item just changed, so we need to update the visibility |
1142 | // of the corresponding handle (if one exists). |
1143 | |
1144 | const int handleIndex = handleIndexForSplitIndex(splitIndex: itemIndex); |
1145 | if (handleIndex != -1) { |
1146 | QQuickItem *handleItem = m_handleItems.at(i: handleIndex); |
1147 | handleItem->setVisible(item->isVisible()); |
1148 | |
1149 | qCDebug(qlcQQuickSplitView) << "set visible property of handle item" |
1150 | << handleItem << "at index"<< handleIndex << "to"<< item->isVisible(); |
1151 | } |
1152 | |
1153 | updateHandleVisibilities(); |
1154 | updateFillIndex(); |
1155 | requestLayout(); |
1156 | } |
1157 | |
1158 | void QQuickSplitViewPrivate::itemImplicitWidthChanged(QQuickItem *) |
1159 | { |
1160 | requestLayout(); |
1161 | } |
1162 | |
1163 | void QQuickSplitViewPrivate::itemImplicitHeightChanged(QQuickItem *) |
1164 | { |
1165 | requestLayout(); |
1166 | } |
1167 | |
1168 | void QQuickSplitViewPrivate::updatePolish() |
1169 | { |
1170 | layout(); |
1171 | } |
1172 | |
1173 | QQuickSplitViewPrivate *QQuickSplitViewPrivate::get(QQuickSplitView *splitView) |
1174 | { |
1175 | return splitView->d_func(); |
1176 | } |
1177 | |
1178 | QQuickSplitView::QQuickSplitView(QQuickItem *parent) |
1179 | : QQuickContainer(*(new QQuickSplitViewPrivate), parent) |
1180 | { |
1181 | Q_D(QQuickSplitView); |
1182 | d->changeTypes |= QQuickItemPrivate::Visibility; |
1183 | |
1184 | setFiltersChildMouseEvents(true); |
1185 | } |
1186 | |
1187 | QQuickSplitView::QQuickSplitView(QQuickSplitViewPrivate &dd, QQuickItem *parent) |
1188 | : QQuickContainer(dd, parent) |
1189 | { |
1190 | Q_D(QQuickSplitView); |
1191 | d->changeTypes |= QQuickItemPrivate::Visibility; |
1192 | |
1193 | setFiltersChildMouseEvents(true); |
1194 | } |
1195 | |
1196 | QQuickSplitView::~QQuickSplitView() |
1197 | { |
1198 | Q_D(QQuickSplitView); |
1199 | for (int i = 0; i < d->contentModel->count(); ++i) { |
1200 | QQuickItem *item = qobject_cast<QQuickItem*>(o: d->contentModel->object(index: i)); |
1201 | d->removeImplicitSizeListener(item); |
1202 | } |
1203 | } |
1204 | |
1205 | /*! |
1206 | \qmlproperty enumeration QtQuick.Controls::SplitView::orientation |
1207 | |
1208 | This property holds the orientation of the SplitView. |
1209 | |
1210 | The orientation determines how the split items are laid out: |
1211 | |
1212 | Possible values: |
1213 | \value Qt.Horizontal The items are laid out horizontally (default). |
1214 | \value Qt.Vertical The items are laid out vertically. |
1215 | */ |
1216 | Qt::Orientation QQuickSplitView::orientation() const |
1217 | { |
1218 | Q_D(const QQuickSplitView); |
1219 | return d->m_orientation; |
1220 | } |
1221 | |
1222 | void QQuickSplitView::setOrientation(Qt::Orientation orientation) |
1223 | { |
1224 | Q_D(QQuickSplitView); |
1225 | if (orientation == d->m_orientation) |
1226 | return; |
1227 | |
1228 | d->m_orientation = orientation; |
1229 | |
1230 | #if QT_CONFIG(cursor) |
1231 | for (QQuickItem *handleItem : d->m_handleItems) |
1232 | d->updateCursorHandle(handleItem); |
1233 | #endif |
1234 | emit orientationChanged(); |
1235 | |
1236 | // Do this after emitting orientationChanged so that the bindings in QML |
1237 | // update the implicit size in time. |
1238 | d->resizeHandles(); |
1239 | // This is queued (via polish) anyway, but to make our intentions clear, |
1240 | // do it afterwards too. |
1241 | d->requestLayout(); |
1242 | } |
1243 | |
1244 | /*! |
1245 | \qmlproperty bool QtQuick.Controls::SplitView::resizing |
1246 | \readonly |
1247 | |
1248 | This property is \c true when the user is resizing |
1249 | split items by dragging on the splitter handles. |
1250 | */ |
1251 | bool QQuickSplitView::isResizing() const |
1252 | { |
1253 | Q_D(const QQuickSplitView); |
1254 | return d->m_resizing; |
1255 | } |
1256 | |
1257 | /*! |
1258 | \qmlproperty Component QtQuick.Controls::SplitView::handle |
1259 | |
1260 | This property holds the handle component. |
1261 | |
1262 | An instance of this component will be instantiated \c {count - 1} |
1263 | times, as long as \c count is greater than than \c {1}. |
1264 | |
1265 | The following table explains how each handle will be resized |
1266 | depending on the orientation of the split view: |
1267 | |
1268 | \table |
1269 | \header |
1270 | \li Orientation |
1271 | \li Handle Width |
1272 | \li Handle Height |
1273 | \row |
1274 | \li \c Qt.Horizontal |
1275 | \li \c implicitWidth |
1276 | \li The \c height of the SplitView. |
1277 | \row |
1278 | \li \c Qt.Vertical |
1279 | \li The \c width of the SplitView. |
1280 | \li \c implicitHeight |
1281 | \endtable |
1282 | |
1283 | To change the size of the handle for mouse and touch events without |
1284 | changing its visual size, use a \l {Item::}{containmentMask}: |
1285 | |
1286 | \snippet qtquickcontrols-splitview-handle-containmentmask.qml 1 |
1287 | |
1288 | \sa {Customizing SplitView} |
1289 | */ |
1290 | QQmlComponent *QQuickSplitView::handle() |
1291 | { |
1292 | Q_D(const QQuickSplitView); |
1293 | return d->m_handle; |
1294 | } |
1295 | |
1296 | void QQuickSplitView::setHandle(QQmlComponent *handle) |
1297 | { |
1298 | Q_D(QQuickSplitView); |
1299 | if (handle == d->m_handle) |
1300 | return; |
1301 | |
1302 | qCDebug(qlcQQuickSplitView) << "setting handle"<< handle; |
1303 | |
1304 | if (d->m_handle) |
1305 | d->destroyHandles(); |
1306 | |
1307 | d->m_handle = handle; |
1308 | |
1309 | if (d->m_handle) { |
1310 | d->createHandles(); |
1311 | d->updateHandleVisibilities(); |
1312 | } |
1313 | |
1314 | d->requestLayout(); |
1315 | |
1316 | emit handleChanged(); |
1317 | } |
1318 | |
1319 | bool QQuickSplitView::isContent(QQuickItem *item) const |
1320 | { |
1321 | Q_D(const QQuickSplitView); |
1322 | if (!qmlContext(item)) |
1323 | return false; |
1324 | |
1325 | if (QQuickItemPrivate::get(item)->isTransparentForPositioner()) |
1326 | return false; |
1327 | |
1328 | return !d->m_handleItems.contains(t: item); |
1329 | } |
1330 | |
1331 | QQuickSplitViewAttached *QQuickSplitView::qmlAttachedProperties(QObject *object) |
1332 | { |
1333 | return new QQuickSplitViewAttached(object); |
1334 | } |
1335 | |
1336 | /*! |
1337 | \qmlmethod var QtQuick.Controls::SplitView::saveState() |
1338 | |
1339 | Saves the preferred sizes of split items into a byte array and returns it. |
1340 | |
1341 | \sa {Serializing SplitView's State}, restoreState() |
1342 | */ |
1343 | QVariant QQuickSplitView::saveState() |
1344 | { |
1345 | #if QT_CONFIG(cborstreamwriter) |
1346 | Q_D(QQuickSplitView); |
1347 | qCDebug(qlcQQuickSplitViewState) << "saving state for split items in"<< this; |
1348 | |
1349 | // Save the preferred sizes of each split item. |
1350 | QCborArray cborArray; |
1351 | for (int i = 0; i < d->contentModel->count(); ++i) { |
1352 | const QQuickItem *item = qobject_cast<QQuickItem*>(o: d->contentModel->object(index: i)); |
1353 | const QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
1354 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
1355 | // Don't serialise stuff if we don't need to. If a split item was given a preferred |
1356 | // size in QML or it was dragged, it will have an attached object and either |
1357 | // m_isPreferredWidthSet or m_isPreferredHeightSet (or both) will be true, |
1358 | // so items without these can be skipped. We write the index of each item |
1359 | // that has data so that we know which item to set it on when restoring. |
1360 | if (!attached) |
1361 | continue; |
1362 | |
1363 | const QQuickSplitViewAttachedPrivate *attachedPrivate = QQuickSplitViewAttachedPrivate::get(attached); |
1364 | if (!attachedPrivate->m_isPreferredWidthSet && !attachedPrivate->m_isPreferredHeightSet) |
1365 | continue; |
1366 | |
1367 | QCborMap cborMap; |
1368 | cborMap[QLatin1String("index")] = i; |
1369 | if (attachedPrivate->m_isPreferredWidthSet) { |
1370 | cborMap[QLatin1String("preferredWidth")] = static_cast<double>(attachedPrivate->m_preferredWidth); |
1371 | |
1372 | qCDebug(qlcQQuickSplitViewState).nospace() << "- wrote preferredWidth of " |
1373 | << attachedPrivate->m_preferredWidth << " for split item "<< item << " at index "<< i; |
1374 | } |
1375 | if (attachedPrivate->m_isPreferredHeightSet) { |
1376 | cborMap[QLatin1String("preferredHeight")] = static_cast<double>(attachedPrivate->m_preferredHeight); |
1377 | |
1378 | qCDebug(qlcQQuickSplitViewState).nospace() << "- wrote preferredHeight of " |
1379 | << attachedPrivate->m_preferredHeight << " for split item "<< item << " at index "<< i; |
1380 | } |
1381 | |
1382 | cborArray.append(value: cborMap); |
1383 | } |
1384 | |
1385 | const QByteArray byteArray = cborArray.toCborValue().toCbor(); |
1386 | qCDebug(qlcQQuickSplitViewState) << "the resulting byte array is:"<< byteArray; |
1387 | return QVariant(byteArray); |
1388 | #else |
1389 | return QVariant(); |
1390 | #endif |
1391 | } |
1392 | |
1393 | /*! |
1394 | \qmlmethod bool QtQuick.Controls::SplitView::restoreState(state) |
1395 | |
1396 | Reads the preferred sizes from \a state and applies them to the split items. |
1397 | |
1398 | Returns \c true if the state was successfully restored, otherwise \c false. |
1399 | |
1400 | \sa {Serializing SplitView's State}, saveState() |
1401 | */ |
1402 | bool QQuickSplitView::restoreState(const QVariant &state) |
1403 | { |
1404 | const QByteArray cborByteArray = state.toByteArray(); |
1405 | Q_D(QQuickSplitView); |
1406 | if (cborByteArray.isEmpty()) |
1407 | return false; |
1408 | |
1409 | QCborParserError parserError; |
1410 | const QCborValue cborValue(QCborValue::fromCbor(ba: cborByteArray, error: &parserError)); |
1411 | if (parserError.error != QCborError::NoError) { |
1412 | qmlWarning(me: this) << "Error reading SplitView state:"<< parserError.errorString(); |
1413 | return false; |
1414 | } |
1415 | |
1416 | qCDebug(qlcQQuickSplitViewState) << "restoring state for split items of"<< this |
1417 | << "from the following string:"<< state; |
1418 | |
1419 | const QCborArray cborArray(cborValue.toArray()); |
1420 | const int ourCount = d->contentModel->count(); |
1421 | // This could conceivably happen if items were removed from the SplitView since the state was last saved. |
1422 | if (cborArray.size() > ourCount) { |
1423 | qmlWarning(me: this) << "Error reading SplitView state: expected " |
1424 | << ourCount << " or less split items but got "<< cborArray.size(); |
1425 | return false; |
1426 | } |
1427 | |
1428 | for (auto it = cborArray.constBegin(); it != cborArray.constEnd(); ++it) { |
1429 | QCborMap cborMap(it->toMap()); |
1430 | const int splitItemIndex = cborMap.value(key: QLatin1String("index")).toInteger(); |
1431 | const bool isPreferredWidthSet = cborMap.contains(key: QLatin1String("preferredWidth")); |
1432 | const bool isPreferredHeightSet = cborMap.contains(key: QLatin1String("preferredHeight")); |
1433 | |
1434 | QQuickItem *item = qobject_cast<QQuickItem*>(o: d->contentModel->object(index: splitItemIndex)); |
1435 | // If the split item does not have a preferred size specified in QML, it could still have |
1436 | // been resized via dragging before it was saved. In this case, it won't have an |
1437 | // attached object upon application startup, so we create it. |
1438 | QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
1439 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: true)); |
1440 | if (isPreferredWidthSet) { |
1441 | const qreal preferredWidth = cborMap.value(key: QLatin1String("preferredWidth")).toDouble(); |
1442 | attached->setPreferredWidth(preferredWidth); |
1443 | } |
1444 | if (isPreferredHeightSet) { |
1445 | const qreal preferredHeight = cborMap.value(key: QLatin1String("preferredHeight")).toDouble(); |
1446 | attached->setPreferredHeight(preferredHeight); |
1447 | } |
1448 | |
1449 | const QQuickSplitViewAttachedPrivate *attachedPrivate = QQuickSplitViewAttachedPrivate::get(attached); |
1450 | qCDebug(qlcQQuickSplitViewState).nospace() |
1451 | << "- restored the following state for split item "<< item << " at index "<< splitItemIndex |
1452 | << ": preferredWidthSet="<< attachedPrivate->m_isPreferredWidthSet |
1453 | << " preferredWidth="<< attachedPrivate->m_preferredWidth |
1454 | << " preferredHeightSet="<< attachedPrivate->m_isPreferredHeightSet |
1455 | << " preferredHeight="<< attachedPrivate->m_preferredHeight; |
1456 | } |
1457 | |
1458 | return true; |
1459 | } |
1460 | |
1461 | void QQuickSplitView::componentComplete() |
1462 | { |
1463 | Q_D(QQuickSplitView); |
1464 | QQuickControl::componentComplete(); |
1465 | d->updateFillIndex(); |
1466 | d->updatePolish(); |
1467 | } |
1468 | |
1469 | void QQuickSplitView::hoverMoveEvent(QHoverEvent *event) |
1470 | { |
1471 | Q_D(QQuickSplitView); |
1472 | QQuickContainer::hoverMoveEvent(event); |
1473 | |
1474 | QQuickItem *hoveredItem = childAt(x: event->position().toPoint().x(), y: event->position().toPoint().y()); |
1475 | d->updateHoveredHandle(hoveredItem); |
1476 | } |
1477 | |
1478 | void QQuickSplitView::hoverLeaveEvent(QHoverEvent *event) |
1479 | { |
1480 | Q_UNUSED(event); |
1481 | Q_D(QQuickSplitView); |
1482 | // If SplitView is no longer hovered (e.g. visible set to false), clear handle hovered value |
1483 | d->updateHoveredHandle(hoveredItem: nullptr); |
1484 | } |
1485 | |
1486 | bool QQuickSplitView::childMouseEventFilter(QQuickItem *item, QEvent *event) |
1487 | { |
1488 | Q_D(QQuickSplitView); |
1489 | qCDebug(qlcQQuickSplitViewPointer) << "childMouseEventFilter called with"<< item << event; |
1490 | |
1491 | if (Q_LIKELY(event->isPointerEvent())) { |
1492 | auto *pointerEvent = static_cast<QPointerEvent *>(event); |
1493 | const auto &eventPoint = pointerEvent->points().first(); |
1494 | const QPointF point = mapFromItem(item, point: eventPoint.position()); |
1495 | const auto timestamp = pointerEvent->timestamp(); |
1496 | |
1497 | switch (event->type()) { |
1498 | case QEvent::MouseButtonPress: |
1499 | d->handlePress(point, timestamp); |
1500 | // Keep the mouse grab if this item belongs to the handle, |
1501 | // otherwise this event can be stolen e.g. Flickable if we're inside it. |
1502 | if (d->m_pressedHandleIndex != -1) |
1503 | item->setKeepMouseGrab(true); |
1504 | break; |
1505 | case QEvent::MouseButtonRelease: |
1506 | d->handleRelease(point, timestamp); |
1507 | break; |
1508 | case QEvent::MouseMove: |
1509 | d->handleMove(point, timestamp); |
1510 | break; |
1511 | case QEvent::TouchBegin: |
1512 | if (pointerEvent->pointCount() == 1) { |
1513 | d->handlePress(point, timestamp); |
1514 | // We filter the event on behalf of item, but we want the item |
1515 | // to be the exclusive grabber so that we can continue to filter |
1516 | // touch events for it. |
1517 | if (d->m_pressedHandleIndex != -1) { |
1518 | item->setKeepTouchGrab(true); |
1519 | pointerEvent->setExclusiveGrabber(point: eventPoint, exclusiveGrabber: item); |
1520 | } |
1521 | } |
1522 | break; |
1523 | case QEvent::TouchEnd: |
1524 | if (pointerEvent->pointCount() == 1) |
1525 | d->handleRelease(point, timestamp); |
1526 | break; |
1527 | case QEvent::TouchUpdate: |
1528 | if (pointerEvent->pointCount() == 1) |
1529 | d->handleMove(point, timestamp); |
1530 | break; |
1531 | default: |
1532 | break; |
1533 | } |
1534 | } |
1535 | |
1536 | // If this event belongs to the handle, filter it. (d->m_pressedHandleIndex != -1) means that |
1537 | // we press or move the handle, so we don't need to propagate it further. |
1538 | if (d->m_pressedHandleIndex != -1) |
1539 | return true; |
1540 | |
1541 | return QQuickContainer::childMouseEventFilter(item, event); |
1542 | } |
1543 | |
1544 | void QQuickSplitView::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) |
1545 | { |
1546 | Q_D(QQuickSplitView); |
1547 | QQuickControl::geometryChange(newGeometry, oldGeometry); |
1548 | d->resizeHandles(); |
1549 | d->requestLayout(); |
1550 | } |
1551 | |
1552 | void QQuickSplitView::itemAdded(int index, QQuickItem *item) |
1553 | { |
1554 | Q_D(QQuickSplitView); |
1555 | if (QQuickItemPrivate::get(item)->isTransparentForPositioner()) |
1556 | return; |
1557 | |
1558 | const int count = d->contentModel->count(); |
1559 | qCDebug(qlcQQuickSplitView).nospace() << "split item "<< item << " added at index "<< index |
1560 | << "; there are now "<< count << " items"; |
1561 | |
1562 | QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
1563 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
1564 | if (attached) |
1565 | QQuickSplitViewAttachedPrivate::get(attached)->setView(this); |
1566 | |
1567 | // Only need to add handles if we have more than one split item. |
1568 | if (count > 1) { |
1569 | // If the item was added at the end, it shouldn't get a handle; |
1570 | // the handle always goes to the split item on the left. |
1571 | d->createHandleItem(index: index < count - 1 ? index : index - 1); |
1572 | } |
1573 | |
1574 | d->addImplicitSizeListener(item); |
1575 | |
1576 | d->updateHandleVisibilities(); |
1577 | d->updateFillIndex(); |
1578 | d->requestLayout(); |
1579 | } |
1580 | |
1581 | void QQuickSplitView::itemMoved(int index, QQuickItem *item) |
1582 | { |
1583 | Q_D(QQuickSplitView); |
1584 | if (!item || QQuickItemPrivate::get(item)->isTransparentForPositioner()) |
1585 | return; |
1586 | |
1587 | qCDebug(qlcQQuickSplitView) << "split item"<< item << "moved to index"<< index; |
1588 | |
1589 | d->updateHandleVisibilities(); |
1590 | d->updateFillIndex(); |
1591 | d->requestLayout(); |
1592 | } |
1593 | |
1594 | void QQuickSplitView::itemRemoved(int index, QQuickItem *item) |
1595 | { |
1596 | Q_D(QQuickSplitView); |
1597 | if (QQuickItemPrivate::get(item)->isTransparentForPositioner()) |
1598 | return; |
1599 | |
1600 | qCDebug(qlcQQuickSplitView).nospace() << "split item "<< item << " removed from index "<< index |
1601 | << "; there are now "<< d->contentModel->count() << " items"; |
1602 | |
1603 | // Clear hovered/pressed handle if there are any. |
1604 | if (d->m_hoveredHandleIndex != -1 || d->m_pressedHandleIndex != -1) { |
1605 | const int handleIndex = d->m_hoveredHandleIndex != -1 ? d->m_hoveredHandleIndex : d->m_pressedHandleIndex; |
1606 | QQuickItem *itemHandle = d->m_handleItems.at(i: handleIndex); |
1607 | QQuickSplitHandleAttached *handleAttached = qobject_cast<QQuickSplitHandleAttached*>( |
1608 | object: qmlAttachedPropertiesObject<QQuickSplitHandleAttached>(obj: itemHandle, create: false)); |
1609 | if (handleAttached) { |
1610 | auto handleAttachedPrivate = QQuickSplitHandleAttachedPrivate::get(attached: handleAttached); |
1611 | handleAttachedPrivate->setHovered(false); |
1612 | handleAttachedPrivate->setPressed(false); |
1613 | } |
1614 | |
1615 | d->m_hoveredHandleIndex = -1; |
1616 | d->m_pressedHandleIndex = -1; |
1617 | } |
1618 | |
1619 | // Unset any attached properties since the item is no longer owned by us. |
1620 | QQuickSplitViewAttached *attached = qobject_cast<QQuickSplitViewAttached*>( |
1621 | object: qmlAttachedPropertiesObject<QQuickSplitView>(obj: item, create: false)); |
1622 | if (attached) |
1623 | QQuickSplitViewAttachedPrivate::get(attached)->setView(this); |
1624 | |
1625 | d->removeImplicitSizeListener(item); |
1626 | |
1627 | d->removeExcessHandles(); |
1628 | d->updateHandleVisibilities(); |
1629 | d->updateFillIndex(); |
1630 | d->requestLayout(); |
1631 | } |
1632 | |
1633 | #if QT_CONFIG(accessibility) |
1634 | QAccessible::Role QQuickSplitView::accessibleRole() const |
1635 | { |
1636 | return QAccessible::Pane; |
1637 | } |
1638 | #endif |
1639 | |
1640 | QQuickSplitViewAttached::QQuickSplitViewAttached(QObject *parent) |
1641 | : QObject(*(new QQuickSplitViewAttachedPrivate), parent) |
1642 | { |
1643 | Q_D(QQuickSplitViewAttached); |
1644 | QQuickItem *item = qobject_cast<QQuickItem *>(o: parent); |
1645 | if (!item) { |
1646 | qmlWarning(me: parent) << "SplitView: attached properties can only be used on Items"; |
1647 | return; |
1648 | } |
1649 | |
1650 | if (QQuickItemPrivate::get(item)->isTransparentForPositioner()) |
1651 | return; |
1652 | |
1653 | d->m_splitItem = item; |
1654 | |
1655 | // Child items get added to SplitView's contentItem, so we have to ensure |
1656 | // that exists first before trying to set m_splitView. |
1657 | // Apparently, in some cases it's normal for the parent item |
1658 | // to not exist until shortly after this constructor has run. |
1659 | if (!item->parentItem()) |
1660 | return; |
1661 | |
1662 | // This will get hit when attached SplitView properties are imperatively set |
1663 | // on an item that previously had none set, for example. |
1664 | QQuickSplitView *splitView = qobject_cast<QQuickSplitView*>(object: item->parentItem()->parentItem()); |
1665 | if (!splitView) { |
1666 | qmlWarning(me: parent) << "SplitView: attached properties must be accessed through a direct child of SplitView"; |
1667 | return; |
1668 | } |
1669 | |
1670 | d->setView(splitView); |
1671 | } |
1672 | |
1673 | /*! |
1674 | \qmlattachedproperty SplitView QtQuick.Controls::SplitView::view |
1675 | |
1676 | This attached property holds the split view of the item it is |
1677 | attached to, or \c null if the item is not in a split view. |
1678 | */ |
1679 | QQuickSplitView *QQuickSplitViewAttached::view() const |
1680 | { |
1681 | Q_D(const QQuickSplitViewAttached); |
1682 | return d->m_splitView; |
1683 | } |
1684 | |
1685 | /*! |
1686 | \qmlattachedproperty real QtQuick.Controls::SplitView::minimumWidth |
1687 | |
1688 | This attached property controls the minimum width of the split item. |
1689 | The \l preferredWidth is bound within the \l minimumWidth and |
1690 | \l maximumWidth. A split item cannot be dragged to be smaller than |
1691 | its \c minimumWidth. |
1692 | |
1693 | The default value is \c 0. To reset this property to its default value, |
1694 | set it to \c undefined. |
1695 | |
1696 | \sa maximumWidth, preferredWidth, fillWidth, minimumHeight |
1697 | */ |
1698 | qreal QQuickSplitViewAttached::minimumWidth() const |
1699 | { |
1700 | Q_D(const QQuickSplitViewAttached); |
1701 | return d->m_minimumWidth; |
1702 | } |
1703 | |
1704 | void QQuickSplitViewAttached::setMinimumWidth(qreal width) |
1705 | { |
1706 | Q_D(QQuickSplitViewAttached); |
1707 | d->m_isMinimumWidthSet = true; |
1708 | if (qFuzzyCompare(p1: width, p2: d->m_minimumWidth)) |
1709 | return; |
1710 | |
1711 | d->m_minimumWidth = width; |
1712 | d->requestLayoutView(); |
1713 | emit minimumWidthChanged(); |
1714 | } |
1715 | |
1716 | void QQuickSplitViewAttached::resetMinimumWidth() |
1717 | { |
1718 | Q_D(QQuickSplitViewAttached); |
1719 | const qreal oldEffectiveMinimumWidth = effectiveMinimumWidth(attachedPrivate: d); |
1720 | |
1721 | d->m_isMinimumWidthSet = false; |
1722 | d->m_minimumWidth = -1; |
1723 | |
1724 | const qreal newEffectiveMinimumWidth = effectiveMinimumWidth(attachedPrivate: d); |
1725 | if (qFuzzyCompare(p1: newEffectiveMinimumWidth, p2: oldEffectiveMinimumWidth)) |
1726 | return; |
1727 | |
1728 | d->requestLayoutView(); |
1729 | emit minimumWidthChanged(); |
1730 | } |
1731 | |
1732 | /*! |
1733 | \qmlattachedproperty real QtQuick.Controls::SplitView::minimumHeight |
1734 | |
1735 | This attached property controls the minimum height of the split item. |
1736 | The \l preferredHeight is bound within the \l minimumHeight and |
1737 | \l maximumHeight. A split item cannot be dragged to be smaller than |
1738 | its \c minimumHeight. |
1739 | |
1740 | The default value is \c 0. To reset this property to its default value, |
1741 | set it to \c undefined. |
1742 | |
1743 | \sa maximumHeight, preferredHeight, fillHeight, minimumWidth |
1744 | */ |
1745 | qreal QQuickSplitViewAttached::minimumHeight() const |
1746 | { |
1747 | Q_D(const QQuickSplitViewAttached); |
1748 | return d->m_minimumHeight; |
1749 | } |
1750 | |
1751 | void QQuickSplitViewAttached::setMinimumHeight(qreal height) |
1752 | { |
1753 | Q_D(QQuickSplitViewAttached); |
1754 | d->m_isMinimumHeightSet = true; |
1755 | if (qFuzzyCompare(p1: height, p2: d->m_minimumHeight)) |
1756 | return; |
1757 | |
1758 | d->m_minimumHeight = height; |
1759 | d->requestLayoutView(); |
1760 | emit minimumHeightChanged(); |
1761 | } |
1762 | |
1763 | void QQuickSplitViewAttached::resetMinimumHeight() |
1764 | { |
1765 | Q_D(QQuickSplitViewAttached); |
1766 | const qreal oldEffectiveMinimumHeight = effectiveMinimumHeight(attachedPrivate: d); |
1767 | |
1768 | d->m_isMinimumHeightSet = false; |
1769 | d->m_minimumHeight = -1; |
1770 | |
1771 | const qreal newEffectiveMinimumHeight = effectiveMinimumHeight(attachedPrivate: d); |
1772 | if (qFuzzyCompare(p1: newEffectiveMinimumHeight, p2: oldEffectiveMinimumHeight)) |
1773 | return; |
1774 | |
1775 | d->requestLayoutView(); |
1776 | emit minimumHeightChanged(); |
1777 | } |
1778 | |
1779 | /*! |
1780 | \qmlattachedproperty real QtQuick.Controls::SplitView::preferredWidth |
1781 | |
1782 | This attached property controls the preferred width of the split item. The |
1783 | preferred width will be used as the size of the item, and will be bound |
1784 | within the \l minimumWidth and \l maximumWidth. If the preferred width |
1785 | is not set, the item's \l {Item::}{implicitWidth} will be used. |
1786 | |
1787 | When a split item is resized, the preferredWidth will be set in order |
1788 | to keep track of the new size. |
1789 | |
1790 | By default, this property is not set, and therefore |
1791 | \l {Item::}{implicitWidth} will be used instead. To reset this property to |
1792 | its default value, set it to \c undefined. |
1793 | |
1794 | \note Do not set the \l{Item::}{width} property of a split item, as it will be |
1795 | overwritten upon each layout of the SplitView. |
1796 | |
1797 | \sa minimumWidth, maximumWidth, fillWidth, preferredHeight |
1798 | */ |
1799 | qreal QQuickSplitViewAttached::preferredWidth() const |
1800 | { |
1801 | Q_D(const QQuickSplitViewAttached); |
1802 | return d->m_preferredWidth; |
1803 | } |
1804 | |
1805 | void QQuickSplitViewAttached::setPreferredWidth(qreal width) |
1806 | { |
1807 | Q_D(QQuickSplitViewAttached); |
1808 | d->m_isPreferredWidthSet = true; |
1809 | // Make sure that we clear this flag now, before we emit the change signals |
1810 | // which could cause another setter to be called. |
1811 | auto splitViewPrivate = d->m_splitView ? QQuickSplitViewPrivate::get(splitView: d->m_splitView) : nullptr; |
1812 | const bool ignoreNextLayoutRequest = splitViewPrivate && splitViewPrivate->m_ignoreNextLayoutRequest; |
1813 | if (splitViewPrivate) |
1814 | splitViewPrivate->m_ignoreNextLayoutRequest = false; |
1815 | |
1816 | if (qFuzzyCompare(p1: width, p2: d->m_preferredWidth)) |
1817 | return; |
1818 | |
1819 | d->m_preferredWidth = width; |
1820 | |
1821 | if (!ignoreNextLayoutRequest) { |
1822 | // We are currently in the middle of performing a layout, and the user (not our internal code) |
1823 | // changed the preferred width of one of the split items, so request another layout. |
1824 | d->requestLayoutView(); |
1825 | } |
1826 | |
1827 | emit preferredWidthChanged(); |
1828 | } |
1829 | |
1830 | void QQuickSplitViewAttached::resetPreferredWidth() |
1831 | { |
1832 | Q_D(QQuickSplitViewAttached); |
1833 | const qreal oldEffectivePreferredWidth = effectivePreferredWidth( |
1834 | attachedPrivate: d, itemPrivate: QQuickItemPrivate::get(item: d->m_splitItem)); |
1835 | |
1836 | d->m_isPreferredWidthSet = false; |
1837 | d->m_preferredWidth = -1; |
1838 | |
1839 | const qreal newEffectivePreferredWidth = effectivePreferredWidth( |
1840 | attachedPrivate: d, itemPrivate: QQuickItemPrivate::get(item: d->m_splitItem)); |
1841 | if (qFuzzyCompare(p1: newEffectivePreferredWidth, p2: oldEffectivePreferredWidth)) |
1842 | return; |
1843 | |
1844 | d->requestLayoutView(); |
1845 | emit preferredWidthChanged(); |
1846 | } |
1847 | |
1848 | /*! |
1849 | \qmlattachedproperty real QtQuick.Controls::SplitView::preferredHeight |
1850 | |
1851 | This attached property controls the preferred height of the split item. The |
1852 | preferred height will be used as the size of the item, and will be bound |
1853 | within the \l minimumHeight and \l maximumHeight. If the preferred height |
1854 | is not set, the item's \l{Item::}{implicitHeight} will be used. |
1855 | |
1856 | When a split item is resized, the preferredHeight will be set in order |
1857 | to keep track of the new size. |
1858 | |
1859 | By default, this property is not set, and therefore |
1860 | \l{Item::}{implicitHeight} will be used instead. To reset this property to |
1861 | its default value, set it to \c undefined. |
1862 | |
1863 | \note Do not set the \l{Item::}{height} property of a split item, as it will be |
1864 | overwritten upon each layout of the SplitView. |
1865 | |
1866 | \sa minimumHeight, maximumHeight, fillHeight, preferredWidth |
1867 | */ |
1868 | qreal QQuickSplitViewAttached::preferredHeight() const |
1869 | { |
1870 | Q_D(const QQuickSplitViewAttached); |
1871 | return d->m_preferredHeight; |
1872 | } |
1873 | |
1874 | void QQuickSplitViewAttached::setPreferredHeight(qreal height) |
1875 | { |
1876 | Q_D(QQuickSplitViewAttached); |
1877 | d->m_isPreferredHeightSet = true; |
1878 | // Make sure that we clear this flag now, before we emit the change signals |
1879 | // which could cause another setter to be called. |
1880 | auto splitViewPrivate = d->m_splitView ? QQuickSplitViewPrivate::get(splitView: d->m_splitView) : nullptr; |
1881 | const bool ignoreNextLayoutRequest = splitViewPrivate && splitViewPrivate->m_ignoreNextLayoutRequest; |
1882 | if (splitViewPrivate) |
1883 | splitViewPrivate->m_ignoreNextLayoutRequest = false; |
1884 | |
1885 | if (qFuzzyCompare(p1: height, p2: d->m_preferredHeight)) |
1886 | return; |
1887 | |
1888 | d->m_preferredHeight = height; |
1889 | |
1890 | if (!ignoreNextLayoutRequest) { |
1891 | // We are currently in the middle of performing a layout, and the user (not our internal code) |
1892 | // changed the preferred height of one of the split items, so request another layout. |
1893 | d->requestLayoutView(); |
1894 | } |
1895 | |
1896 | emit preferredHeightChanged(); |
1897 | } |
1898 | |
1899 | void QQuickSplitViewAttached::resetPreferredHeight() |
1900 | { |
1901 | Q_D(QQuickSplitViewAttached); |
1902 | const qreal oldEffectivePreferredHeight = effectivePreferredHeight( |
1903 | attachedPrivate: d, itemPrivate: QQuickItemPrivate::get(item: d->m_splitItem)); |
1904 | |
1905 | d->m_isPreferredHeightSet = false; |
1906 | d->m_preferredHeight = -1; |
1907 | |
1908 | const qreal newEffectivePreferredHeight = effectivePreferredHeight( |
1909 | attachedPrivate: d, itemPrivate: QQuickItemPrivate::get(item: d->m_splitItem)); |
1910 | if (qFuzzyCompare(p1: newEffectivePreferredHeight, p2: oldEffectivePreferredHeight)) |
1911 | return; |
1912 | |
1913 | d->requestLayoutView(); |
1914 | emit preferredHeightChanged(); |
1915 | } |
1916 | |
1917 | /*! |
1918 | \qmlattachedproperty real QtQuick.Controls::SplitView::maximumWidth |
1919 | |
1920 | This attached property controls the maximum width of the split item. |
1921 | The \l preferredWidth is bound within the \l minimumWidth and |
1922 | \l maximumWidth. A split item cannot be dragged to be larger than |
1923 | its \c maximumWidth. |
1924 | |
1925 | The default value is \c Infinity. To reset this property to its default |
1926 | value, set it to \c undefined. |
1927 | |
1928 | \sa minimumWidth, preferredWidth, fillWidth, maximumHeight |
1929 | */ |
1930 | qreal QQuickSplitViewAttached::maximumWidth() const |
1931 | { |
1932 | Q_D(const QQuickSplitViewAttached); |
1933 | return d->m_maximumWidth; |
1934 | } |
1935 | |
1936 | void QQuickSplitViewAttached::setMaximumWidth(qreal width) |
1937 | { |
1938 | Q_D(QQuickSplitViewAttached); |
1939 | d->m_isMaximumWidthSet = true; |
1940 | if (qFuzzyCompare(p1: width, p2: d->m_maximumWidth)) |
1941 | return; |
1942 | |
1943 | d->m_maximumWidth = width; |
1944 | d->requestLayoutView(); |
1945 | emit maximumWidthChanged(); |
1946 | } |
1947 | |
1948 | void QQuickSplitViewAttached::resetMaximumWidth() |
1949 | { |
1950 | Q_D(QQuickSplitViewAttached); |
1951 | const qreal oldEffectiveMaximumWidth = effectiveMaximumWidth(attachedPrivate: d); |
1952 | |
1953 | d->m_isMaximumWidthSet = false; |
1954 | d->m_maximumWidth = -1; |
1955 | |
1956 | const qreal newEffectiveMaximumWidth = effectiveMaximumWidth(attachedPrivate: d); |
1957 | if (qFuzzyCompare(p1: newEffectiveMaximumWidth, p2: oldEffectiveMaximumWidth)) |
1958 | return; |
1959 | |
1960 | d->requestLayoutView(); |
1961 | emit maximumWidthChanged(); |
1962 | } |
1963 | |
1964 | /*! |
1965 | \qmlattachedproperty real QtQuick.Controls::SplitView::maximumHeight |
1966 | |
1967 | This attached property controls the maximum height of the split item. |
1968 | The \l preferredHeight is bound within the \l minimumHeight and |
1969 | \l maximumHeight. A split item cannot be dragged to be larger than |
1970 | its \c maximumHeight. |
1971 | |
1972 | The default value is \c Infinity. To reset this property to its default |
1973 | value, set it to \c undefined. |
1974 | |
1975 | \sa minimumHeight, preferredHeight, fillHeight, maximumWidth |
1976 | */ |
1977 | qreal QQuickSplitViewAttached::maximumHeight() const |
1978 | { |
1979 | Q_D(const QQuickSplitViewAttached); |
1980 | return d->m_maximumHeight; |
1981 | } |
1982 | |
1983 | void QQuickSplitViewAttached::setMaximumHeight(qreal height) |
1984 | { |
1985 | Q_D(QQuickSplitViewAttached); |
1986 | d->m_isMaximumHeightSet = true; |
1987 | if (qFuzzyCompare(p1: height, p2: d->m_maximumHeight)) |
1988 | return; |
1989 | |
1990 | d->m_maximumHeight = height; |
1991 | d->requestLayoutView(); |
1992 | emit maximumHeightChanged(); |
1993 | } |
1994 | |
1995 | void QQuickSplitViewAttached::resetMaximumHeight() |
1996 | { |
1997 | Q_D(QQuickSplitViewAttached); |
1998 | const qreal oldEffectiveMaximumHeight = effectiveMaximumHeight(attachedPrivate: d); |
1999 | |
2000 | d->m_isMaximumHeightSet = false; |
2001 | d->m_maximumHeight = -1; |
2002 | |
2003 | const qreal newEffectiveMaximumHeight = effectiveMaximumHeight(attachedPrivate: d); |
2004 | if (qFuzzyCompare(p1: newEffectiveMaximumHeight, p2: oldEffectiveMaximumHeight)) |
2005 | return; |
2006 | |
2007 | d->requestLayoutView(); |
2008 | emit maximumHeightChanged(); |
2009 | } |
2010 | |
2011 | /*! |
2012 | \qmlattachedproperty bool QtQuick.Controls::SplitView::fillWidth |
2013 | |
2014 | This attached property controls whether the item takes the remaining space |
2015 | in the split view after all other items have been laid out. |
2016 | |
2017 | By default, the last visible child of the split view will fill the view, |
2018 | but it can be changed by explicitly setting \c fillWidth to \c true on |
2019 | another item. If multiple items have \c fillWidth set to \c true, the |
2020 | left-most item will fill the view. |
2021 | |
2022 | The width of a split item with \c fillWidth set to \c true is still |
2023 | restricted within its \l minimumWidth and \l maximumWidth. |
2024 | |
2025 | \sa minimumWidth, preferredWidth, maximumWidth, fillHeight |
2026 | */ |
2027 | bool QQuickSplitViewAttached::fillWidth() const |
2028 | { |
2029 | Q_D(const QQuickSplitViewAttached); |
2030 | return d->m_fillWidth; |
2031 | } |
2032 | |
2033 | void QQuickSplitViewAttached::setFillWidth(bool fill) |
2034 | { |
2035 | Q_D(QQuickSplitViewAttached); |
2036 | d->m_isFillWidthSet = true; |
2037 | if (fill == d->m_fillWidth) |
2038 | return; |
2039 | |
2040 | d->m_fillWidth = fill; |
2041 | if (d->m_splitView && d->m_splitView->orientation() == Qt::Horizontal) |
2042 | QQuickSplitViewPrivate::get(splitView: d->m_splitView)->updateFillIndex(); |
2043 | d->requestLayoutView(); |
2044 | emit fillWidthChanged(); |
2045 | } |
2046 | |
2047 | /*! |
2048 | \qmlattachedproperty bool QtQuick.Controls::SplitView::fillHeight |
2049 | |
2050 | This attached property controls whether the item takes the remaining space |
2051 | in the split view after all other items have been laid out. |
2052 | |
2053 | By default, the last visible child of the split view will fill the view, |
2054 | but it can be changed by explicitly setting \c fillHeight to \c true on |
2055 | another item. If multiple items have \c fillHeight set to \c true, the |
2056 | top-most item will fill the view. |
2057 | |
2058 | The height of a split item with \c fillHeight set to \c true is still |
2059 | restricted within its \l minimumHeight and \l maximumHeight. |
2060 | |
2061 | \sa minimumHeight, preferredHeight, maximumHeight, fillWidth |
2062 | */ |
2063 | bool QQuickSplitViewAttached::fillHeight() const |
2064 | { |
2065 | Q_D(const QQuickSplitViewAttached); |
2066 | return d->m_fillHeight; |
2067 | } |
2068 | |
2069 | void QQuickSplitViewAttached::setFillHeight(bool fill) |
2070 | { |
2071 | Q_D(QQuickSplitViewAttached); |
2072 | d->m_isFillHeightSet = true; |
2073 | if (fill == d->m_fillHeight) |
2074 | return; |
2075 | |
2076 | d->m_fillHeight = fill; |
2077 | if (d->m_splitView && d->m_splitView->orientation() == Qt::Vertical) |
2078 | QQuickSplitViewPrivate::get(splitView: d->m_splitView)->updateFillIndex(); |
2079 | d->requestLayoutView(); |
2080 | emit fillHeightChanged(); |
2081 | } |
2082 | |
2083 | QQuickSplitViewAttachedPrivate::QQuickSplitViewAttachedPrivate() |
2084 | : m_fillWidth(false) |
2085 | , m_fillHeight(false) |
2086 | , m_isFillWidthSet(false) |
2087 | , m_isFillHeightSet(false) |
2088 | , m_isMinimumWidthSet(false) |
2089 | , m_isMinimumHeightSet(false) |
2090 | , m_isPreferredWidthSet(false) |
2091 | , m_isPreferredHeightSet(false) |
2092 | , m_isMaximumWidthSet(false) |
2093 | , m_isMaximumHeightSet(false) |
2094 | , m_minimumWidth(0) |
2095 | , m_minimumHeight(0) |
2096 | , m_preferredWidth(-1) |
2097 | , m_preferredHeight(-1) |
2098 | , m_maximumWidth(std::numeric_limits<qreal>::infinity()) |
2099 | , m_maximumHeight(std::numeric_limits<qreal>::infinity()) |
2100 | { |
2101 | } |
2102 | |
2103 | void QQuickSplitViewAttachedPrivate::setView(QQuickSplitView *newView) |
2104 | { |
2105 | Q_Q(QQuickSplitViewAttached); |
2106 | if (newView == m_splitView) |
2107 | return; |
2108 | |
2109 | m_splitView = newView; |
2110 | qCDebug(qlcQQuickSplitView) << "set SplitView"<< newView << "on attached object"<< this; |
2111 | emit q->viewChanged(); |
2112 | } |
2113 | |
2114 | void QQuickSplitViewAttachedPrivate::requestLayoutView() |
2115 | { |
2116 | if (m_splitView) |
2117 | QQuickSplitViewPrivate::get(splitView: m_splitView)->requestLayout(); |
2118 | } |
2119 | |
2120 | QQuickSplitViewAttachedPrivate *QQuickSplitViewAttachedPrivate::get(QQuickSplitViewAttached *attached) |
2121 | { |
2122 | return attached->d_func(); |
2123 | } |
2124 | |
2125 | const QQuickSplitViewAttachedPrivate *QQuickSplitViewAttachedPrivate::get(const QQuickSplitViewAttached *attached) |
2126 | { |
2127 | return attached->d_func(); |
2128 | } |
2129 | |
2130 | QQuickSplitHandleAttachedPrivate::QQuickSplitHandleAttachedPrivate() |
2131 | : m_hovered(false) |
2132 | , m_pressed(false) |
2133 | { |
2134 | } |
2135 | |
2136 | void QQuickSplitHandleAttachedPrivate::setHovered(bool hovered) |
2137 | { |
2138 | Q_Q(QQuickSplitHandleAttached); |
2139 | if (hovered == m_hovered) |
2140 | return; |
2141 | |
2142 | m_hovered = hovered; |
2143 | emit q->hoveredChanged(); |
2144 | } |
2145 | |
2146 | void QQuickSplitHandleAttachedPrivate::setPressed(bool pressed) |
2147 | { |
2148 | Q_Q(QQuickSplitHandleAttached); |
2149 | if (pressed == m_pressed) |
2150 | return; |
2151 | |
2152 | m_pressed = pressed; |
2153 | emit q->pressedChanged(); |
2154 | } |
2155 | |
2156 | QQuickSplitHandleAttachedPrivate *QQuickSplitHandleAttachedPrivate::get(QQuickSplitHandleAttached *attached) |
2157 | { |
2158 | return attached->d_func(); |
2159 | } |
2160 | |
2161 | const QQuickSplitHandleAttachedPrivate *QQuickSplitHandleAttachedPrivate::get(const QQuickSplitHandleAttached *attached) |
2162 | { |
2163 | return attached->d_func(); |
2164 | } |
2165 | |
2166 | QQuickSplitHandleAttached::QQuickSplitHandleAttached(QObject *parent) |
2167 | : QObject(*(new QQuickSplitHandleAttachedPrivate), parent) |
2168 | { |
2169 | } |
2170 | |
2171 | /*! |
2172 | \qmltype SplitHandle |
2173 | \inherits QtObject |
2174 | //! \nativetype QQuickSplitHandleAttached |
2175 | \inqmlmodule QtQuick.Controls |
2176 | \since 5.13 |
2177 | \brief Provides attached properties for SplitView handles. |
2178 | |
2179 | SplitHandle provides attached properties for \l SplitView handles. |
2180 | |
2181 | For split items themselves, use the attached \l SplitView properties. |
2182 | |
2183 | \sa SplitView |
2184 | */ |
2185 | |
2186 | /*! |
2187 | \qmlattachedproperty bool QtQuick.Controls::SplitHandle::hovered |
2188 | |
2189 | This attached property holds whether the split handle is hovered. |
2190 | |
2191 | \sa pressed |
2192 | */ |
2193 | bool QQuickSplitHandleAttached::isHovered() const |
2194 | { |
2195 | Q_D(const QQuickSplitHandleAttached); |
2196 | return d->m_hovered; |
2197 | } |
2198 | |
2199 | /*! |
2200 | \qmlattachedproperty bool QtQuick.Controls::SplitHandle::pressed |
2201 | |
2202 | This attached property holds whether the split handle is pressed. |
2203 | |
2204 | \sa hovered |
2205 | */ |
2206 | bool QQuickSplitHandleAttached::isPressed() const |
2207 | { |
2208 | Q_D(const QQuickSplitHandleAttached); |
2209 | return d->m_pressed; |
2210 | } |
2211 | |
2212 | QQuickSplitHandleAttached *QQuickSplitHandleAttached::qmlAttachedProperties(QObject *object) |
2213 | { |
2214 | return new QQuickSplitHandleAttached(object); |
2215 | } |
2216 | |
2217 | QT_END_NAMESPACE |
2218 | |
2219 | #include "moc_qquicksplitview_p.cpp" |
2220 |
Definitions
- qlcQQuickSplitView
- qlcQQuickSplitViewPointer
- qlcQQuickSplitViewState
- updateFillIndex
- layoutResizeSplitItems
- layoutResizeFillItem
- limitAndApplySizes
- layoutPositionItems
- requestLayout
- layout
- createHandles
- createHandleItem
- removeExcessHandles
- accumulatedSize
- effectiveMinimumWidth
- effectiveMinimumHeight
- effectivePreferredWidth
- effectivePreferredHeight
- effectiveMaximumWidth
- effectiveMaximumHeight
- effectiveSizeData
- handleIndexForSplitIndex
- destroyHandles
- resizeHandle
- resizeHandles
- updateCursorHandle
- updateHandleVisibilities
- updateHoveredHandle
- setResizing
- isHorizontal
- getContentItem
- handlePress
- handleMove
- handleRelease
- itemVisibilityChanged
- itemImplicitWidthChanged
- itemImplicitHeightChanged
- updatePolish
- get
- QQuickSplitView
- QQuickSplitView
- ~QQuickSplitView
- orientation
- setOrientation
- isResizing
- handle
- setHandle
- isContent
- qmlAttachedProperties
- saveState
- restoreState
- componentComplete
- hoverMoveEvent
- hoverLeaveEvent
- childMouseEventFilter
- geometryChange
- itemAdded
- itemMoved
- itemRemoved
- accessibleRole
- QQuickSplitViewAttached
- view
- minimumWidth
- setMinimumWidth
- resetMinimumWidth
- minimumHeight
- setMinimumHeight
- resetMinimumHeight
- preferredWidth
- setPreferredWidth
- resetPreferredWidth
- preferredHeight
- setPreferredHeight
- resetPreferredHeight
- maximumWidth
- setMaximumWidth
- resetMaximumWidth
- maximumHeight
- setMaximumHeight
- resetMaximumHeight
- fillWidth
- setFillWidth
- fillHeight
- setFillHeight
- QQuickSplitViewAttachedPrivate
- setView
- requestLayoutView
- get
- get
- QQuickSplitHandleAttachedPrivate
- setHovered
- setPressed
- get
- get
- QQuickSplitHandleAttached
- isHovered
- isPressed
Start learning QML with our Intro Training
Find out more