1
=== modified file 'Components/Carousel.qml'
2
--- Components/Carousel.qml	2013-06-06 07:57:05 +0000
3
+++ Components/Carousel.qml	2013-07-01 11:23:32 +0000
4
@@ -24,6 +24,8 @@
5
24
Item {
24
Item {
6
25
    id: carousel
25
    id: carousel
7
26
26
8
27
    clip: true // Don't leak horizontally to other dashes
9
28
10
27
    /// The component to be used as delegate. This component has to be derived from BaseCarouselDelegate
29
    /// The component to be used as delegate. This component has to be derived from BaseCarouselDelegate
11
28
    property Component itemComponent
30
    property Component itemComponent
12
29
    /// Model for the Carousel, which has to be a model usable by a ListView
31
    /// Model for the Carousel, which has to be a model usable by a ListView
13
30
32
14
=== modified file 'Components/ListItems/Base.qml'
15
--- Components/ListItems/Base.qml	2013-06-05 22:03:08 +0000
16
+++ Components/ListItems/Base.qml	2013-07-01 11:23:32 +0000
17
@@ -54,35 +54,33 @@
18
54
     */
54
     */
19
55
    function __showDivider() {
55
    function __showDivider() {
20
56
        // if we're not in ListView, always show a thin dividing line at the bottom
56
        // if we're not in ListView, always show a thin dividing line at the bottom
23
57
        if (ListView.view !== null) {
57
        var model = null;
24
58
58
        if (typeof ListViewWithPageHeader !== 'undefined') {
25
59
            if (typeof ListViewWithPageHeader.model !== 'undefined') {
26
60
                model = ListViewWithPageHeader.model;
27
61
            }
28
62
        } else if (ListView.view !== null) {
29
63
            model = ListView.view.model;
30
64
        }
31
59
            // if we're last item in ListView don't show divider
65
            // if we're last item in ListView don't show divider
34
60
            if (index === ListView.view.model.count - 1) return false;
66
        if (model && index === model.count - 1) return false;
35
61
        }
67
36
62
        return true;
68
        return true;
37
63
    }
69
    }
38
64
70
43
65
    property bool __clippingRequired: ListView.view !== null
71
    /* Relevant really only for ListViewWithPageHeader case: specify how many pixels we can overlap with the section header */
44
66
                                      && ListView.view.section.labelPositioning & ViewSection.CurrentLabelAtStart
72
    readonly property int allowedOverlap: units.dp(1)
41
67
42
68
    property real __yPositionRelativeToListView: ListView.view ? y - ListView.view.contentY : y
45
69
73
46
70
    property real __heightToClip: {
74
    property real __heightToClip: {
47
71
        // Check this is in position where clipping is needed
75
        // Check this is in position where clipping is needed
62
72
        if (__clippingRequired && __yPositionRelativeToListView <= __sectionDelegateHeight
76
        if (typeof ListViewWithPageHeader !== 'undefined') {
63
73
                && __yPositionRelativeToListView > -height) {
77
            if (typeof heightToClip !== 'undefined') {
64
74
            return Math.min(__sectionDelegateHeight - __yPositionRelativeToListView, height);
78
                if (heightToClip >= allowedOverlap) {
65
75
        } else {
79
                    return heightToClip - allowedOverlap;
66
76
            return 0;
80
                }
67
77
        }
81
            }
68
78
    }
82
        }
69
79
83
        return 0;
56
80
    property int __sectionDelegateHeight: {
57
81
        if (__clippingRequired && ListView.view.hasOwnProperty("__sectionDelegateHeight")) {
58
82
            return ListView.view.__sectionDelegateHeight;
59
83
        } else {
60
84
            return 0;
61
85
        }
70
86
    }
84
    }
71
87
85
72
88
    /*!
86
    /*!
73
89
87
74
=== modified file 'Components/ListItems/Header.qml'
75
--- Components/ListItems/Header.qml	2013-06-05 22:03:08 +0000
76
+++ Components/ListItems/Header.qml	2013-07-01 11:23:32 +0000
77
@@ -25,12 +25,6 @@
78
25
    */
25
    */
79
26
    property alias text: label.text
26
    property alias text: label.text
80
27
27
81
28
    /* When this header is used in a ListViewWithPageHeader with CurrentLabelAtStart mode, to stop
82
29
       the list's delegates contents being visible through this header, they clip themselves
83
30
       depending on their position. However to allow delegates underlap the bottom X pixels of this
84
31
       header (so delegate appears through ThinDivider say) we set an offset property here. */
85
32
    readonly property int bottomBorderAllowedOverlap: bottomBorder.allowedBottomOverlap
86
33
87
34
    height: units.gu(4.5)
28
    height: units.gu(4.5)
88
35
29
89
36
    Item {
30
    Item {
90
37
31
91
=== modified file 'Components/ListItems/ThinDivider.qml'
92
--- Components/ListItems/ThinDivider.qml	2013-06-05 22:03:08 +0000
93
+++ Components/ListItems/ThinDivider.qml	2013-07-01 11:23:32 +0000
94
@@ -23,9 +23,5 @@
95
23
    }
23
    }
96
24
    height: (visible) ? units.dp(2) : 0
24
    height: (visible) ? units.dp(2) : 0
97
25
25
98
26
    /* Relevant really only for ListViewWithPageHeader with Base delegates: should this image
99
27
       be overlapping content, specify how many pixels from the bottom should be transparent */
100
28
    readonly property int allowedBottomOverlap: units.dp(1)
101
29
102
30
    source: "graphics/ListItemDividerHorizontal.png"
26
    source: "graphics/ListItemDividerHorizontal.png"
103
31
}
27
}
104
32
28
105
=== removed file 'Components/ListViewWithPageHeader.qml'
106
--- Components/ListViewWithPageHeader.qml	2013-06-05 22:03:08 +0000
107
+++ Components/ListViewWithPageHeader.qml	1970-01-01 00:00:00 +0000
108
@@ -1,189 +0,0 @@
109
1
/*
110
2
 * Copyright (C) 2013 Canonical, Ltd.
111
3
 *
112
4
 * This program is free software; you can redistribute it and/or modify
113
5
 * it under the terms of the GNU General Public License as published by
114
6
 * the Free Software Foundation; version 3.
115
7
 *
116
8
 * This program is distributed in the hope that it will be useful,
117
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
118
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
119
11
 * GNU General Public License for more details.
120
12
 *
121
13
 * You should have received a copy of the GNU General Public License
122
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
123
15
 */
124
16
125
17
import QtQuick 2.0
126
18
import "Math.js" as MathLocal
127
19
128
20
Item {
129
21
    id: root
130
22
    property Item pageHeader: null
131
23
    property Component sectionDelegate: null
132
24
    property string sectionProperty: ""
133
25
    property alias model: listView.model
134
26
    property alias delegate: listView.delegate
135
27
    property ListView view: listView
136
28
    property alias moving: flicker.moving
137
29
    property alias atYEnd: flicker.atYEnd
138
30
    property bool clipListView: true
139
31
140
32
    readonly property real __headerHeight: (pageHeader) ? pageHeader.implicitHeight : 0
141
33
    property real __headerVisibleHeight: __headerHeight
142
34
    readonly property real __overshootHeight: (flicker.contentY < 0) ? -flicker.contentY : 0
143
35
144
36
145
37
    // TODO move to AnimationController
146
38
    ParallelAnimation {
147
39
        id: headerAnimation
148
40
        property real targetContentY
149
41
        NumberAnimation {
150
42
            target: root
151
43
            property: "__headerVisibleHeight"
152
44
            to: root.__headerHeight
153
45
            duration: 200
154
46
            easing.type: Easing.OutQuad
155
47
        }
156
48
        NumberAnimation {
157
49
            target: listView
158
50
            property: "contentY"
159
51
            to: headerAnimation.targetContentY
160
52
            duration: 200
161
53
            easing.type: Easing.OutQuad
162
54
        }
163
55
    }
164
56
165
57
    function positionAtBeginning() {
166
58
        __headerVisibleHeight = __headerHeight
167
59
        flicker.contentY = 0
168
60
    }
169
61
170
62
    function showHeader() {
171
63
        headerAnimation.targetContentY = listView.contentY + (__headerHeight - __headerVisibleHeight)
172
64
        headerAnimation.start()
173
65
    }
174
66
175
67
    function flick(xVelocity, yVelocity) {
176
68
        flicker.flick(xVelocity, yVelocity);
177
69
    }
178
70
179
71
    onPageHeaderChanged: {
180
72
        pageHeader.parent = pageHeaderContainer;
181
73
        pageHeader.anchors.fill = pageHeaderContainer;
182
74
    }
183
75
184
76
    Item {
185
77
        id: pageHeaderClipper
186
78
        parent: flicker // parent to Flickable so mouse click events passed through to the header component
187
79
        anchors {
188
80
            top: parent.top
189
81
            left: parent.left
190
82
            right: parent.right
191
83
        }
192
84
        height: __headerVisibleHeight + __overshootHeight
193
85
194
86
        Item {
195
87
            id: pageHeaderContainer
196
88
            anchors {
197
89
                left: parent.left
198
90
                right: parent.right
199
91
                bottom: parent.bottom
200
92
            }
201
93
            height: __headerHeight + __overshootHeight
202
94
        }
203
95
    }
204
96
205
97
    ListView {
206
98
        id: listView
207
99
        parent: flicker // parent to Flickable so mouse click events passed through to List delegates
208
100
        anchors {
209
101
            left: parent.left
210
102
            right: parent.right
211
103
            top: parent.top
212
104
            topMargin: __headerVisibleHeight
213
105
        }
214
106
        height: root.height
215
107
216
108
        // FIXME scrolling workaround, see below
217
109
        cacheBuffer: height*10
218
110
219
111
        section.property: sectionProperty
220
112
        section.criteria: ViewSection.FullString
221
113
        section.labelPositioning: ViewSection.InlineLabels | ViewSection.CurrentLabelAtStart
222
114
        section.delegate: sectionDelegate
223
115
224
116
        interactive: false
225
117
        clip: root.clipListView
226
118
227
119
        property int __sectionDelegateHeight: __getHeight(section.delegate)
228
120
        function __getHeight(component) {
229
121
            // want height (minus allowed overlap) of the section delegate as is needed for clipping
230
122
            if (component === null) return 0;
231
123
            var object = component.createObject(); //FIXME: throws 'section' not defined error
232
124
            var value = object.height - object.bottomBorderAllowedOverlap;
233
125
            object.destroy();
234
126
            return value;
235
127
        }
236
128
237
129
        property real previousOriginY: 0
238
130
        onOriginYChanged: {
239
131
            var deltaOriginY = originY - previousOriginY;
240
132
            previousOriginY = originY;
241
133
            /* When originY changes, it causes the top of the flicker and the top of the list to fall
242
134
               out of sync - and thus the contentY positioning will be broken. To correct for this we
243
135
               manually change the flickable's contentY here */
244
136
            flicker.contentY -= deltaOriginY;
245
137
        }
246
138
247
139
        /* For case when list content greater than container height and list scrolled down so header
248
140
           hidden. If content shrinks to be smaller than the container height, we want the header to
249
141
           re-appear */
250
142
        property real __previousContentHeight: 0
251
143
        onContentHeightChanged: {
252
144
            var deltaContentHeight = contentHeight - __previousContentHeight;
253
145
            __previousContentHeight = contentHeight;
254
146
            if (contentHeight < height && deltaContentHeight < 0 && __headerVisibleHeight < height - contentHeight) {
255
147
                __headerVisibleHeight = Math.min(height - contentHeight, __headerHeight);
256
148
            }
257
149
        }
258
150
    }
259
151
260
152
    Flickable {
261
153
        id: flicker
262
154
        anchors.fill: parent
263
155
        contentHeight: listView.contentHeight + __headerHeight
264
156
        maximumFlickVelocity: height * 10
265
157
        flickDeceleration: height * 2
266
158
        onContentYChanged: {
267
159
            var deltaContentY = contentY - __previousContentY;
268
160
            __previousContentY = contentY;
269
161
270
162
            // first decide if movement will prompt the page header to change height
271
163
            if ((deltaContentY < 0 && __headerVisibleHeight >= 0) ||
272
164
                    (deltaContentY > 0 && __headerVisibleHeight <= __headerHeight)) {
273
165
274
166
                // calculate header height - but prevent bounce from changing it
275
167
                if (contentY > 0 && contentY < contentHeight - height) {
276
168
                    __headerVisibleHeight = MathLocal.clamp(__headerVisibleHeight - deltaContentY, 0, __headerHeight);
277
169
                }
278
170
            }
279
171
280
172
            // now we move list position, taking into account page header height
281
173
282
174
            // BUG: With section headers enabled, the values of originY and contentY appear not
283
175
            // correct at the exact point originY changes. originY changes when the ListView
284
176
            // deletes/creates hidden delegates which are above the visible delegates.
285
177
            // As a result of this bug, you experience jittering scrolling when rapidly moving
286
178
            // around in large lists. See https://bugreports.qt-project.org/browse/QTBUG-27997
287
179
            // A workaround is to use a large enough cacheBuffer to prevent deletions/creations
288
180
            // so effectively originY is always zero.
289
181
            var newContentY = flicker.contentY + listView.originY - __headerHeight + __headerVisibleHeight
290
182
            if (newContentY < listView.contentHeight) {
291
183
                listView.contentY = newContentY;
292
184
            }
293
185
        }
294
186
295
187
        property real __previousContentY: 0
296
188
    }
297
189
}
298
190
0
299
=== modified file 'Dash/DashApps.qml'
300
--- Dash/DashApps.qml	2013-06-12 12:52:35 +0000
301
+++ Dash/DashApps.qml	2013-07-01 11:23:32 +0000
302
@@ -99,7 +99,7 @@
303
99
       When using Loader to load external QML file in the list deelgate, the ListView has
99
       When using Loader to load external QML file in the list deelgate, the ListView has
304
100
       a bug where it can position the delegate content to overlap the section header
100
       a bug where it can position the delegate content to overlap the section header
305
101
       of the ListView - a workaround is to use sourceComponent of Loader instead */
101
       of the ListView - a workaround is to use sourceComponent of Loader instead */
307
102
    Component { id: runningApplicationsGrid; RunningApplicationsGrid {} }
102
    Component { id: runningApplicationsGrid; RunningApplicationsGrid { clip: true } }
308
103
    Component {
103
    Component {
309
104
        id: applicationsFilterGrid;
104
        id: applicationsFilterGrid;
310
105
        ApplicationsFilterGrid {
105
        ApplicationsFilterGrid {
311
@@ -112,7 +112,7 @@
312
112
        "ApplicationsFilterGrid": applicationsFilterGrid,
112
        "ApplicationsFilterGrid": applicationsFilterGrid,
313
113
    }
113
    }
314
114
114
316
115
    ListViewWithPageHeader {
115
    ScopeListView {
317
116
        id: categoryView
116
        id: categoryView
318
117
        anchors.fill: parent
117
        anchors.fill: parent
319
118
        model: SortFilterProxyModel {
118
        model: SortFilterProxyModel {
320
@@ -150,7 +150,6 @@
321
150
                        item.model = categoryModels[modelName]
150
                        item.model = categoryModels[modelName]
322
151
                    }
151
                    }
323
152
                }
152
                }
324
153
                asynchronous: true
325
154
            }
153
            }
326
155
154
327
156
            ListView.onRemove: SequentialAnimation {
155
            ListView.onRemove: SequentialAnimation {
328
157
156
329
=== modified file 'Dash/DashHome.qml'
330
--- Dash/DashHome.qml	2013-06-14 13:54:08 +0000
331
+++ Dash/DashHome.qml	2013-07-01 11:23:32 +0000
332
@@ -130,7 +130,7 @@
333
130
                "VideosGrid": videosGrid,
130
                "VideosGrid": videosGrid,
334
131
    }
131
    }
335
132
132
337
133
    ListViewWithPageHeader {
133
    ScopeListView {
338
134
        id: listView
134
        id: listView
339
135
        anchors.fill: parent
135
        anchors.fill: parent
340
136
        model: categoryListModel
136
        model: categoryListModel
341
@@ -161,7 +161,6 @@
342
161
                        item.clicked.connect(playVideo);
161
                        item.clicked.connect(playVideo);
343
162
                    }
162
                    }
344
163
                }
163
                }
345
164
                asynchronous: true
346
165
            }
164
            }
347
166
        }
165
        }
348
167
166
349
168
167
350
=== modified file 'Dash/DashMusic.qml'
351
--- Dash/DashMusic.qml	2013-06-14 20:57:40 +0000
352
+++ Dash/DashMusic.qml	2013-07-01 11:23:32 +0000
353
@@ -64,7 +64,7 @@
354
64
        }
64
        }
355
65
    }
65
    }
356
66
66
358
67
    ListViewWithPageHeader {
67
    ScopeListView {
359
68
        id: categoryView
68
        id: categoryView
360
69
        anchors.fill: parent
69
        anchors.fill: parent
361
70
        model: scopeView.categories
70
        model: scopeView.categories
362
@@ -84,7 +84,6 @@
363
84
                onLoaded: {
84
                onLoaded: {
364
85
                    item.model = results
85
                    item.model = results
365
86
                }
86
                }
366
87
                asynchronous: true
367
88
            }
87
            }
368
89
        }
88
        }
369
90
89
370
91
90
371
=== modified file 'Dash/DashVideos.qml'
372
--- Dash/DashVideos.qml	2013-06-14 20:57:40 +0000
373
+++ Dash/DashVideos.qml	2013-07-01 11:23:32 +0000
374
@@ -97,11 +97,11 @@
375
97
        }
97
        }
376
98
    }
98
    }
377
99
99
379
100
    ListViewWithPageHeader {
100
    ScopeListView {
380
101
        id: categoryView
101
        id: categoryView
381
102
        anchors.fill: parent
102
        anchors.fill: parent
382
103
        model: scopeView.categories
103
        model: scopeView.categories
384
104
        clipListView: !previewLoader.onScreen
104
        forceNoClip: previewLoader.onScreen
385
105
105
386
106
        onAtYEndChanged: if (atYEnd) endReached()
106
        onAtYEndChanged: if (atYEnd) endReached()
387
107
        onMovingChanged: if (moving && atYEnd) endReached()
107
        onMovingChanged: if (moving && atYEnd) endReached()
388
@@ -119,7 +119,6 @@
389
119
                onLoaded: {
119
                onLoaded: {
390
120
                    item.model = results
120
                    item.model = results
391
121
                }
121
                }
392
122
                asynchronous: true
393
123
122
394
124
                Connections {
123
                Connections {
395
125
                    target: loader.item
124
                    target: loader.item
396
126
125
397
=== modified file 'Dash/GenericScopeView.qml'
398
--- Dash/GenericScopeView.qml	2013-06-12 12:52:35 +0000
399
+++ Dash/GenericScopeView.qml	2013-07-01 11:23:32 +0000
400
@@ -43,7 +43,7 @@
401
43
        }
43
        }
402
44
    }
44
    }
403
45
45
405
46
    ListViewWithPageHeader {
46
    ScopeListView {
406
47
        id: categoryView
47
        id: categoryView
407
48
        anchors.fill: parent
48
        anchors.fill: parent
408
49
        model: scopeView.categories
49
        model: scopeView.categories
409
50
50
410
=== added file 'Dash/ScopeListView.qml'
411
--- Dash/ScopeListView.qml	1970-01-01 00:00:00 +0000
412
+++ Dash/ScopeListView.qml	2013-07-01 11:23:32 +0000
413
@@ -0,0 +1,23 @@
414
1
/*
415
2
 * Copyright (C) 2013 Canonical, Ltd.
416
3
 *
417
4
 * This program is free software; you can redistribute it and/or modify
418
5
 * it under the terms of the GNU General Public License as published by
419
6
 * the Free Software Foundation; version 3.
420
7
 *
421
8
 * This program is distributed in the hope that it will be useful,
422
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
423
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
424
11
 * GNU General Public License for more details.
425
12
 *
426
13
 * You should have received a copy of the GNU General Public License
427
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
428
15
 */
429
16
430
17
import QtQuick 2.0
431
18
import ListViewWithPageHeader 0.1
432
19
433
20
ListViewWithPageHeader {
434
21
    maximumFlickVelocity: height * 10
435
22
    flickDeceleration: height * 2
436
23
}
437
0
24
438
=== modified file 'debian/control'
439
--- debian/control	2013-06-20 00:01:16 +0000
440
+++ debian/control	2013-07-01 11:23:32 +0000
441
@@ -11,6 +11,7 @@
442
11
               libgles2-mesa-dev[armhf],
11
               libgles2-mesa-dev[armhf],
443
12
               libhud-client2-dev,
12
               libhud-client2-dev,
444
13
               libpulse-dev,
13
               libpulse-dev,
445
14
               libqt5v8-5-private-dev,
446
14
               libunity-core-6.0-dev (<< 7.80),
15
               libunity-core-6.0-dev (<< 7.80),
447
15
               libxcb1-dev,
16
               libxcb1-dev,
448
16
               pkg-config,
17
               pkg-config,
449
@@ -20,6 +21,7 @@
450
20
               qtbase5-private-dev,
21
               qtbase5-private-dev,
451
21
               qtdeclarative5-dev,
22
               qtdeclarative5-dev,
452
22
               qtdeclarative5-dev-tools,
23
               qtdeclarative5-dev-tools,
453
24
               qtdeclarative5-private-dev,
454
23
               qtdeclarative5-qtquick2-plugin,
25
               qtdeclarative5-qtquick2-plugin,
455
24
               qtdeclarative5-test-plugin,
26
               qtdeclarative5-test-plugin,
456
25
               qtdeclarative5-ubuntu-ui-toolkit-plugin,
27
               qtdeclarative5-ubuntu-ui-toolkit-plugin,
457
26
28
458
=== modified file 'debian/unity8.install'
459
--- debian/unity8.install	2013-06-05 22:03:08 +0000
460
+++ debian/unity8.install	2013-07-01 11:23:32 +0000
461
@@ -15,6 +15,7 @@
462
15
/usr/share/unity8/graphics/*
15
/usr/share/unity8/graphics/*
463
16
/usr/share/unity8/plugins/HudClient/*
16
/usr/share/unity8/plugins/HudClient/*
464
17
/usr/share/unity8/plugins/LightDM/*
17
/usr/share/unity8/plugins/LightDM/*
465
18
/usr/share/unity8/plugins/ListViewWithPageHeader/*
466
18
/usr/share/unity8/plugins/Ubuntu/*
19
/usr/share/unity8/plugins/Ubuntu/*
467
19
/usr/share/unity8/plugins/Unity/*
20
/usr/share/unity8/plugins/Unity/*
468
20
/usr/share/unity8/plugins/Utils/*
21
/usr/share/unity8/plugins/Utils/*
469
21
22
470
=== modified file 'plugins/CMakeLists.txt'
471
--- plugins/CMakeLists.txt	2013-06-05 22:03:08 +0000
472
+++ plugins/CMakeLists.txt	2013-07-01 11:23:32 +0000
473
@@ -3,3 +3,4 @@
474
3
add_subdirectory(Unity)
3
add_subdirectory(Unity)
475
4
add_subdirectory(HudClient)
4
add_subdirectory(HudClient)
476
5
add_subdirectory(LightDM)
5
add_subdirectory(LightDM)
477
6
add_subdirectory(ListViewWithPageHeader)
478
6
7
479
=== added directory 'plugins/ListViewWithPageHeader'
480
=== added file 'plugins/ListViewWithPageHeader/CMakeLists.txt'
481
--- plugins/ListViewWithPageHeader/CMakeLists.txt	1970-01-01 00:00:00 +0000
482
+++ plugins/ListViewWithPageHeader/CMakeLists.txt	2013-07-01 11:23:32 +0000
483
@@ -0,0 +1,44 @@
484
1
# There's no cmake var for v8 include path :-/
485
2
# so create one
486
3
LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)
487
4
SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/../QtV8/${Qt5Core_VERSION_STRING}/QtV8)
488
5
489
6
include_directories(
490
7
    ${CMAKE_CURRENT_SOURCE_DIR}
491
8
    ${CMAKE_CURRENT_BINARY_DIR}
492
9
    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
493
10
    ${Qt5Quick_INCLUDE_DIRS}
494
11
    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
495
12
    ${Qt5V8_PRIVATE_INCLUDE_DIR}
496
13
)
497
14
498
15
remove_definitions(-DQT_NO_KEYWORDS)
499
16
500
17
set(QMLPLUGIN_SRC
501
18
    plugin.cpp
502
19
    listviewwithpageheader.cpp
503
20
    )
504
21
505
22
add_library(ListViewWithPageHeader-qml MODULE
506
23
    ${QMLPLUGIN_SRC}
507
24
    )
508
25
509
26
target_link_libraries(ListViewWithPageHeader-qml
510
27
    ${Qt5Gui_LIBRARIES}
511
28
    ${Qt5Quick_LIBRARIES}
512
29
    )
513
30
514
31
qt5_use_modules(ListViewWithPageHeader-qml Qml Quick)
515
32
516
33
# copy qmldir file into build directory for shadow builds
517
34
file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/qmldir"
518
35
    DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
519
36
    )
520
37
521
38
install(TARGETS ListViewWithPageHeader-qml
522
39
    DESTINATION ${SHELL_APP_DIR}/plugins/ListViewWithPageHeader
523
40
    )
524
41
525
42
install(FILES qmldir
526
43
    DESTINATION ${SHELL_APP_DIR}/plugins/ListViewWithPageHeader
527
44
    )
528
0
45
529
=== added file 'plugins/ListViewWithPageHeader/listviewwithpageheader.cpp'
530
--- plugins/ListViewWithPageHeader/listviewwithpageheader.cpp	1970-01-01 00:00:00 +0000
531
+++ plugins/ListViewWithPageHeader/listviewwithpageheader.cpp	2013-07-01 11:23:32 +0000
532
@@ -0,0 +1,1059 @@
533
1
/*
534
2
 * Copyright (C) 2013 Canonical, Ltd.
535
3
 *
536
4
 * This program is free software; you can redistribute it and/or modify
537
5
 * it under the terms of the GNU General Public License as published by
538
6
 * the Free Software Foundation; version 3.
539
7
 *
540
8
 * This program is distributed in the hope that it will be useful,
541
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
542
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
543
11
 * GNU General Public License for more details.
544
12
 *
545
13
 * You should have received a copy of the GNU General Public License
546
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
547
15
 */
548
16
549
17
/*
550
18
 * Some documentation on how this thing works:
551
19
 *
552
20
 * A flickable has two very important concepts that define the top and
553
21
 * height of the flickable area.
554
22
 * The top is returned in minYExtent()
555
23
 * The height is set using setContentHeight()
556
24
 * By changing those two values we can make the list grow up or down
557
25
 * as needed. e.g. if we are in the middle of the list
558
26
 * and something that is above the viewport grows, since we do not
559
27
 * want to change the viewport because of that we just adjust the
560
28
 * minYExtent so that the list grows up.
561
29
 *
562
30
 * The implementation on the list relies on the delegateModel doing
563
31
 * most of the instantiation work. You call createItem() when you
564
32
 * need to create an item asking for it async or not. If returns null
565
33
 * it means the item will be created async and the model will call the
566
34
 * itemCreated slot with the item.
567
35
 *
568
36
 * updatePolish is the central point of dispatch for the work of the
569
37
 * class. It is called by the scene graph just before drawing the class.
570
38
 * In it we:
571
39
 *  * Make sure all items are positioned correctly
572
40
 *  * Add/Remove items if needed
573
41
 *  * Update the content height if it was dirty
574
42
 *
575
43
 * m_visibleItems contains all the items we have created at the moment.
576
44
 * Actually not all of them are visible since it includes the ones
577
45
 * in the cache area we create asynchronously to help performance.
578
46
 * The first item in m_visibleItems has the m_firstVisibleIndex in
579
47
 * the model. If you actually want to know what is the first
580
48
 * item in the viewport you have to find the first non culled element
581
49
 * in m_visibleItems
582
50
 *
583
51
 * All the items (except the header) are childs of m_clipItem which
584
52
 * is a child of the contentItem() of the flickable (The contentItem()
585
53
 * is what actually 'moves' in a a flickable). This way
586
54
 * we can implement the clipping needed so we can have the header
587
55
 * shown in the middle of the list over the items without the items
588
56
 * leaking under the header in case it is transparent.
589
57
 *
590
58
 * The first item of m_visibleItems is the one that defines the
591
59
 * positions of all the rest of items (see updatePolish()) and
592
60
 * this is why sometimes we move it even if it's not the item
593
61
 * that has triggered the function (i.e. in itemGeometryChanged())
594
62
 *
595
63
 * m_visibleItems is a list of ListItem. Each ListItem
596
64
 * will contain a item and potentially a sectionItem. The sectionItem
597
65
 * is only there when the list is using sectionDelegate+sectionProperty
598
66
 * and this is the first item of the section. Each ListItem is vertically
599
67
 * layouted with the sectionItem first and then the item.
600
68
 *
601
69
 * For sectioning we also have a section item alone (m_topSectionItem)
602
70
 * that is used for the cases we need to show the sticky section item at
603
71
 * the top of the view.
604
72
 *
605
73
 * Each delegate item has a context property called heightToClip that is
606
74
 * used to communicate to the delegate implementation in case it has to
607
75
 * clip itself because of overlapping with the top sticky section item.
608
76
 * This is an implementation decision since it has been agreed it
609
77
 * is easier to implement the clipping in QML with this info than to
610
78
 * do it at the C++ level.
611
79
 *
612
80
 * Note that minYExtent and height are not always totally accurate, since
613
81
 * we don't have the items created we can't guess their heights
614
82
 * so we can only guarantee the values are correct when the first/last
615
83
 * items of the list are visible, otherwise we just live with good enough
616
84
 * values that make the list scrollable
617
85
 *
618
86
 * There are a few things that are not really implemented or tested properly
619
87
 * which we don't use at the moment like changing the model, changing
620
88
 * the section delegate, having a section delegate that changes its size, etc.
621
89
 * The known missing features are marked with TODOs along the code.
622
90
 */
623
91
624
92
#include "listviewwithpageheader.h"
625
93
626
94
#include <QDebug>
627
95
#include <qqmlinfo.h>
628
96
#include <qqmlengine.h>
629
97
#include <private/qquickvisualdatamodel_p.h>
630
98
#include <private/qqmlglobal_p.h>
631
99
#include <private/qquickitem_p.h>
632
100
#include <private/qquickanimation_p.h>
633
101
// #include <private/qquickrectangle_p.h>
634
102
635
103
static const qreal bufferRatio = 0.5;
636
104
637
105
qreal ListViewWithPageHeader::ListItem::height() const
638
106
{
639
107
    return m_item->height() + (m_sectionItem ? m_sectionItem->height() : 0);
640
108
}
641
109
642
110
qreal ListViewWithPageHeader::ListItem::y() const
643
111
{
644
112
    return m_item->y() - (m_sectionItem ? m_sectionItem->height() : 0);
645
113
}
646
114
647
115
void ListViewWithPageHeader::ListItem::setY(qreal newY)
648
116
{
649
117
    if (m_sectionItem) {
650
118
        m_sectionItem->setY(newY);
651
119
        m_item->setY(newY + m_sectionItem->height());
652
120
    } else {
653
121
        m_item->setY(newY);
654
122
    }
655
123
}
656
124
657
125
bool ListViewWithPageHeader::ListItem::culled() const
658
126
{
659
127
    return QQuickItemPrivate::get(m_item)->culled;
660
128
}
661
129
662
130
void ListViewWithPageHeader::ListItem::setCulled(bool culled)
663
131
{
664
132
    QQuickItemPrivate::get(m_item)->setCulled(culled);
665
133
    if (m_sectionItem)
666
134
        QQuickItemPrivate::get(m_sectionItem)->setCulled(culled);
667
135
}
668
136
669
137
ListViewWithPageHeader::ListViewWithPageHeader()
670
138
 : m_delegateModel(nullptr)
671
139
 , m_asyncRequestedIndex(-1)
672
140
 , m_delegateValidated(false)
673
141
 , m_firstVisibleIndex(-1)
674
142
 , m_minYExtent(0)
675
143
 , m_contentHeightDirty(false)
676
144
 , m_headerItem(nullptr)
677
145
 , m_previousContentY(0)
678
146
 , m_headerItemShownHeight(0)
679
147
 , m_sectionDelegate(nullptr)
680
148
 , m_topSectionItem(nullptr)
681
149
 , m_forceNoClip(false)
682
150
 , m_inLayout(false)
683
151
{
684
152
    m_clipItem = new QQuickItem(contentItem());
685
153
//     m_clipItem = new QQuickRectangle(contentItem());
686
154
//     ((QQuickRectangle*)m_clipItem)->setColor(Qt::gray);
687
155
688
156
    m_headerShowAnimation = new QQuickNumberAnimation(this);
689
157
    m_headerShowAnimation->setEasing(QEasingCurve::OutQuad);
690
158
    m_headerShowAnimation->setProperty("contentY");
691
159
    m_headerShowAnimation->setDuration(200);
692
160
    m_headerShowAnimation->setTargetObject(this);
693
161
694
162
    connect(this, SIGNAL(contentWidthChanged()), this, SLOT(onContentWidthChanged()));
695
163
    connect(this, SIGNAL(contentHeightChanged()), this, SLOT(onContentHeightChanged()));
696
164
    connect(this, SIGNAL(heightChanged()), this, SLOT(onHeightChanged()));
697
165
    connect(m_headerShowAnimation, SIGNAL(stopped()), this, SLOT(onShowHeaderAnimationFinished()));
698
166
}
699
167
700
168
ListViewWithPageHeader::~ListViewWithPageHeader()
701
169
{
702
170
}
703
171
704
172
QAbstractItemModel *ListViewWithPageHeader::model() const
705
173
{
706
174
    return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() : nullptr;
707
175
}
708
176
709
177
void ListViewWithPageHeader::setModel(QAbstractItemModel *model)
710
178
{
711
179
    if (model != this->model()) {
712
180
        if (!m_delegateModel) {
713
181
            createDelegateModel();
714
182
        } else {
715
183
            disconnect(m_delegateModel, SIGNAL(modelUpdated(QQuickChangeSet,bool)), this, SLOT(onModelUpdated(QQuickChangeSet,bool)));
716
184
        }
717
185
        m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
718
186
        connect(m_delegateModel, SIGNAL(modelUpdated(QQuickChangeSet,bool)), this, SLOT(onModelUpdated(QQuickChangeSet,bool)));
719
187
        Q_EMIT modelChanged();
720
188
        // TODO?
721
189
//         Q_EMIT contentHeightChanged();
722
190
//         Q_EMIT contentYChanged();
723
191
    }
724
192
}
725
193
726
194
QQmlComponent *ListViewWithPageHeader::delegate() const
727
195
{
728
196
    return m_delegateModel ? m_delegateModel->delegate() : nullptr;
729
197
}
730
198
731
199
void ListViewWithPageHeader::setDelegate(QQmlComponent *delegate)
732
200
{
733
201
    if (delegate != this->delegate()) {
734
202
        if (!m_delegateModel) {
735
203
            createDelegateModel();
736
204
        }
737
205
738
206
        // Cleanup the existing items
739
207
        Q_FOREACH(ListItem *item, m_visibleItems)
740
208
            releaseItem(item);
741
209
        m_visibleItems.clear();
742
210
        m_firstVisibleIndex = -1;
743
211
        adjustMinYExtent();
744
212
        setContentY(0);
745
213
        m_clipItem->setY(0);
746
214
        if (m_topSectionItem) {
747
215
            QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
748
216
        }
749
217
750
218
        m_delegateModel->setDelegate(delegate);
751
219
752
220
        Q_EMIT delegateChanged();
753
221
        m_delegateValidated = false;
754
222
        m_contentHeightDirty = true;
755
223
        polish();
756
224
    }
757
225
}
758
226
759
227
QQuickItem *ListViewWithPageHeader::header() const
760
228
{
761
229
    return m_headerItem;
762
230
}
763
231
764
232
void ListViewWithPageHeader::setHeader(QQuickItem *headerItem)
765
233
{
766
234
    if (m_headerItem != headerItem) {
767
235
        qreal oldHeaderHeight = 0;
768
236
        qreal oldHeaderY = 0;
769
237
        if (m_headerItem) {
770
238
            oldHeaderHeight = m_headerItem->height();
771
239
            oldHeaderY = m_headerItem->y();
772
240
            m_headerItem->setParentItem(nullptr);
773
241
        }
774
242
        m_headerItem = headerItem;
775
243
        if (m_headerItem) {
776
244
            m_headerItem->setParentItem(contentItem());
777
245
            m_headerItem->setZ(1);
778
246
        }
779
247
        qreal newHeaderHeight = m_headerItem ? m_headerItem->height() : 0;
780
248
        if (!m_visibleItems.isEmpty() && newHeaderHeight != oldHeaderHeight) {
781
249
            headerHeightChanged(newHeaderHeight, oldHeaderHeight, oldHeaderY);
782
250
            polish();
783
251
            m_contentHeightDirty = true;
784
252
        }
785
253
        Q_EMIT headerChanged();
786
254
    }
787
255
}
788
256
789
257
QQmlComponent *ListViewWithPageHeader::sectionDelegate() const
790
258
{
791
259
    return m_sectionDelegate;
792
260
}
793
261
794
262
void ListViewWithPageHeader::setSectionDelegate(QQmlComponent *delegate)
795
263
{
796
264
    if (delegate != m_sectionDelegate) {
797
265
        // TODO clean existing sections
798
266
799
267
        m_sectionDelegate = delegate;
800
268
801
269
        m_topSectionItem = getSectionItem(QString());
802
270
        m_topSectionItem->setZ(3);
803
271
        QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
804
272
805
273
        // TODO create sections for existing items
806
274
807
275
        Q_EMIT sectionDelegateChanged();
808
276
    }
809
277
}
810
278
811
279
QString ListViewWithPageHeader::sectionProperty() const
812
280
{
813
281
    return m_sectionProperty;
814
282
}
815
283
816
284
void ListViewWithPageHeader::setSectionProperty(const QString &property)
817
285
{
818
286
    if (property != m_sectionProperty) {
819
287
        m_sectionProperty = property;
820
288
821
289
        updateWatchedRoles();
822
290
823
291
        // TODO recreate sections
824
292
825
293
        Q_EMIT sectionPropertyChanged();
826
294
    }
827
295
}
828
296
829
297
bool ListViewWithPageHeader::forceNoClip() const
830
298
{
831
299
    return m_forceNoClip;
832
300
}
833
301
834
302
void ListViewWithPageHeader::setForceNoClip(bool noClip)
835
303
{
836
304
    if (noClip != m_forceNoClip) {
837
305
        m_forceNoClip = noClip;
838
306
        updateClipItem();
839
307
        Q_EMIT forceNoClipChanged();
840
308
    }
841
309
}
842
310
843
311
void ListViewWithPageHeader::positionAtBeginning()
844
312
{
845
313
    qreal headerHeight = (m_headerItem ? m_headerItem->height() : 0);
846
314
    if (m_firstVisibleIndex != 0) {
847
315
        // TODO This could be optimized by trying to reuse the interesection
848
316
        // of items that may end up intersecting between the existing
849
317
        // m_visibleItems and the items we are creating in the next loop
850
318
        Q_FOREACH(ListItem *item, m_visibleItems)
851
319
            releaseItem(item);
852
320
        m_visibleItems.clear();
853
321
        m_firstVisibleIndex = -1;
854
322
855
323
        // Create the item 0, it will be already correctly positioned at createItem()
856
324
        m_clipItem->setY(0);
857
325
        ListItem *item = createItem(0, false);
858
326
        // Create the subsequent items
859
327
        int modelIndex = 1;
860
328
        qreal pos = item->y() + item->height();
861
329
        const qreal buffer = height() * bufferRatio;
862
330
        const qreal bufferTo = height() + buffer;
863
331
        while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
864
332
            if (!(item = createItem(modelIndex, false)))
865
333
                break;
866
334
            pos += item->height();
867
335
            ++modelIndex;
868
336
        }
869
337
870
338
        m_previousContentY = m_visibleItems.first()->y() - headerHeight;
871
339
    }
872
340
    setContentY(m_visibleItems.first()->y() + m_clipItem->y() - headerHeight);
873
341
}
874
342
875
343
void ListViewWithPageHeader::showHeader()
876
344
{
877
345
    auto to = qMax(-minYExtent(), contentY() - m_headerItem->height() + m_headerItemShownHeight);
878
346
    if (to != contentY()) {
879
347
        m_headerShowAnimation->setTo(to);
880
348
        m_headerShowAnimation->start();
881
349
    }
882
350
}
883
351
884
352
qreal ListViewWithPageHeader::minYExtent() const
885
353
{
886
354
//     qDebug() << "ListViewWithPageHeader::minYExtent" << m_minYExtent;
887
355
    return m_minYExtent;
888
356
}
889
357
890
358
void ListViewWithPageHeader::componentComplete()
891
359
{
892
360
    if (m_delegateModel)
893
361
        m_delegateModel->componentComplete();
894
362
895
363
    QQuickFlickable::componentComplete();
896
364
897
365
    polish();
898
366
}
899
367
900
368
void ListViewWithPageHeader::viewportMoved(Qt::Orientations orient)
901
369
{
902
370
    QQuickFlickable::viewportMoved(orient);
903
371
//     qDebug() << "ListViewWithPageHeader::viewportMoved" << contentY();
904
372
    qreal diff = m_previousContentY - contentY();
905
373
    if (m_headerItem) {
906
374
        auto oldHeaderItemShownHeight = m_headerItemShownHeight;
907
375
        if (contentY() < -m_minYExtent) {
908
376
            // Stick the header item to the top when dragging down
909
377
            m_headerItem->setY(contentY());
910
378
            m_headerItem->setHeight(m_headerItem->implicitHeight() + (-m_minYExtent - contentY()));
911
379
        } else {
912
380
            m_headerItem->setHeight(m_headerItem->implicitHeight());
913
381
            // We are going down (but it's not because of the rebound at the end)
914
382
            // (but the header was not shown by it's own position)
915
383
            // or the header is partially shown
916
384
            const bool scrolledUp = m_previousContentY > contentY();
917
385
            const bool notRebounding = contentY() + height() < contentHeight();
918
386
            const bool notShownByItsOwn = contentY() + diff > m_headerItem->y() + m_headerItem->height();
919
387
920
388
            if (!scrolledUp && contentY() == -m_minYExtent) {
921
389
                m_headerItemShownHeight = 0;
922
390
                m_headerItem->setY(contentY());
923
391
            } else if ((scrolledUp && notRebounding && notShownByItsOwn) || (m_headerItemShownHeight > 0)) {
924
392
                m_headerItemShownHeight += diff;
925
393
                if (contentY() == -m_minYExtent) {
926
394
                    m_headerItemShownHeight = 0;
927
395
                } else {
928
396
                    m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, m_headerItem->height());
929
397
                }
930
398
                if (m_headerItemShownHeight > 0) {
931
399
                    m_headerItem->setY(contentY() - m_headerItem->height() + m_headerItemShownHeight);
932
400
                } else {
933
401
                    m_headerItem->setY(-m_minYExtent);
934
402
                }
935
403
            }
936
404
        }
937
405
        // We will be changing the clip item, need to accomadate for it
938
406
        // otherwise we move the firstItem down/up twice (unless the
939
407
        // show header animation is running, where we want to keep the viewport stable)
940
408
        if (!m_headerShowAnimation->isRunning()) {
941
409
            diff += oldHeaderItemShownHeight - m_headerItemShownHeight;
942
410
        } else {
943
411
            diff = -diff;
944
412
        }
945
413
    }
946
414
    if (!m_visibleItems.isEmpty()) {
947
415
        updateClipItem();
948
416
        ListItem *firstItem = m_visibleItems.first();
949
417
        firstItem->setY(firstItem->y() + diff);
950
418
        if (m_headerShowAnimation->isRunning()) {
951
419
            adjustMinYExtent();
952
420
        }
953
421
    }
954
422
955
423
    m_previousContentY = contentY();
956
424
    layout();
957
425
    polish();
958
426
}
959
427
960
428
void ListViewWithPageHeader::createDelegateModel()
961
429
{
962
430
    m_delegateModel = new QQuickVisualDataModel(qmlContext(this), this);
963
431
    connect(m_delegateModel, SIGNAL(createdItem(int,QQuickItem*)), this, SLOT(itemCreated(int,QQuickItem*)));
964
432
    if (isComponentComplete())
965
433
        m_delegateModel->componentComplete();
966
434
    updateWatchedRoles();
967
435
}
968
436
969
437
void ListViewWithPageHeader::refill()
970
438
{
971
439
    if (m_inLayout) {
972
440
        return;
973
441
    }
974
442
    if (!isComponentComplete()) {
975
443
        return;
976
444
    }
977
445
978
446
    const qreal buffer = height() * bufferRatio;
979
447
    const qreal from = contentY();
980
448
    const qreal to = from + height();
981
449
    const qreal bufferFrom = from - buffer;
982
450
    const qreal bufferTo = to + buffer;
983
451
984
452
    bool added = addVisibleItems(from, to, false);
985
453
    bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
986
454
    added |= addVisibleItems(bufferFrom, bufferTo, true);
987
455
988
456
    if (added || removed) {
989
457
        m_contentHeightDirty = true;
990
458
    }
991
459
}
992
460
993
461
bool ListViewWithPageHeader::addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous)
994
462
{
995
463
    if (!delegate())
996
464
        return false;
997
465
998
466
    if (m_delegateModel->count() == 0)
999
467
        return false;
1000
468
1001
469
    ListItem *item;
1002
470
//     qDebug() << "ListViewWithPageHeader::addVisibleItems" << fillFrom << fillTo << asynchronous;
1003
471
1004
472
    int modelIndex = 0;
1005
473
    qreal pos = 0;
1006
474
    if (!m_visibleItems.isEmpty()) {
1007
475
        modelIndex = m_firstVisibleIndex + m_visibleItems.count();
1008
476
        item = m_visibleItems.last();
1009
477
        pos = item->y() + item->height() + m_clipItem->y();
1010
478
    }
1011
479
    bool changed = false;
1012
480
//     qDebug() << (modelIndex < m_delegateModel->count()) << pos << fillTo;
1013
481
    while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
1014
482
//         qDebug() << "refill: append item" << modelIndex << "pos" << pos << "asynchronous" << asynchronous;
1015
483
        if (!(item = createItem(modelIndex, asynchronous)))
1016
484
            break;
1017
485
        pos += item->height();
1018
486
        ++modelIndex;
1019
487
        changed = true;
1020
488
    }
1021
489
1022
490
    modelIndex = 0;
1023
491
    pos = 0;
1024
492
    if (!m_visibleItems.isEmpty()) {
1025
493
        modelIndex = m_firstVisibleIndex - 1;
1026
494
        item = m_visibleItems.first();
1027
495
        pos = item->y() + m_clipItem->y();
1028
496
    }
1029
497
    while (modelIndex >= 0 && pos > fillFrom) {
1030
498
//         qDebug() << "refill: prepend item" << modelIndex << "pos" << pos << "fillFrom" << fillFrom << "asynchronous" << asynchronous;
1031
499
        if (!(item = createItem(modelIndex, asynchronous)))
1032
500
            break;
1033
501
        pos -= item->height();
1034
502
        --modelIndex;
1035
503
        changed = true;
1036
504
    }
1037
505
1038
506
    return changed;
1039
507
}
1040
508
1041
509
void ListViewWithPageHeader::reallyReleaseItem(ListItem *listItem)
1042
510
{
1043
511
    QQuickItem *item = listItem->m_item;
1044
512
    QQuickVisualModel::ReleaseFlags flags = m_delegateModel->release(item);
1045
513
    if (flags & QQuickVisualModel::Destroyed) {
1046
514
        item->setParentItem(nullptr);
1047
515
    }
1048
516
    delete listItem->m_sectionItem;
1049
517
    delete listItem;
1050
518
}
1051
519
1052
520
void ListViewWithPageHeader::releaseItem(ListItem *listItem)
1053
521
{
1054
522
    QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
1055
523
    itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
1056
524
    m_itemsToRelease << listItem;
1057
525
}
1058
526
1059
527
void ListViewWithPageHeader::updateWatchedRoles()
1060
528
{
1061
529
    if (m_delegateModel) {
1062
530
        QList<QByteArray> roles;
1063
531
        if (!m_sectionProperty.isEmpty())
1064
532
            roles << m_sectionProperty.toUtf8();
1065
533
        m_delegateModel->setWatchedRoles(roles);
1066
534
    }
1067
535
}
1068
536
1069
537
QQuickItem *ListViewWithPageHeader::getSectionItem(int modelIndex, bool alreadyInserted)
1070
538
{
1071
539
    if (!m_sectionDelegate)
1072
540
        return nullptr;
1073
541
1074
542
    const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1075
543
    if (modelIndex > 0) {
1076
544
        const QString prevSection = m_delegateModel->stringValue(modelIndex - 1, m_sectionProperty);
1077
545
        if (section == prevSection)
1078
546
            return nullptr;
1079
547
    }
1080
548
    if (modelIndex + 1 < model()->rowCount() && !alreadyInserted) {
1081
549
        // Already inserted items can't steal next section header
1082
550
        const QString nextSection = m_delegateModel->stringValue(modelIndex + 1, m_sectionProperty);
1083
551
        if (section == nextSection) {
1084
552
            // Steal the section header
1085
553
            ListItem *nextItem = itemAtIndex(modelIndex); // Not +1 since not yet inserted into m_visibleItems
1086
554
            if (nextItem) {
1087
555
                QQuickItem *sectionItem = nextItem->m_sectionItem;
1088
556
                nextItem->m_sectionItem = nullptr;
1089
557
                return sectionItem;
1090
558
            }
1091
559
        }
1092
560
    }
1093
561
1094
562
    return getSectionItem(section);
1095
563
}
1096
564
1097
565
QQuickItem *ListViewWithPageHeader::getSectionItem(const QString &sectionText)
1098
566
{
1099
567
    QQuickItem *sectionItem = nullptr;
1100
568
1101
569
    QQmlContext *creationContext = m_sectionDelegate->creationContext();
1102
570
    QQmlContext *context = new QQmlContext(creationContext ? creationContext : qmlContext(this));
1103
571
    context->setContextProperty(QLatin1String("section"), sectionText);
1104
572
    QObject *nobj = m_sectionDelegate->beginCreate(context);
1105
573
    if (nobj) {
1106
574
        QQml_setParent_noEvent(context, nobj);
1107
575
        sectionItem = qobject_cast<QQuickItem *>(nobj);
1108
576
        if (!sectionItem) {
1109
577
            delete nobj;
1110
578
        } else {
1111
579
            sectionItem->setZ(2);
1112
580
            QQml_setParent_noEvent(sectionItem, m_clipItem);
1113
581
            sectionItem->setParentItem(m_clipItem);
1114
582
        }
1115
583
    } else {
1116
584
        delete context;
1117
585
    }
1118
586
    m_sectionDelegate->completeCreate();
1119
587
1120
588
    // TODO attach to sectionItem so we can accomodate to it changing its height
1121
589
1122
590
    return sectionItem;
1123
591
}
1124
592
1125
593
bool ListViewWithPageHeader::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
1126
594
{
1127
595
//     qDebug() << "ListViewWithPageHeader::removeNonVisibleItems" << bufferFrom << bufferTo;
1128
596
    // Do not remove items if we are overshooting up or down, since we'll come back
1129
597
    // to the "stable" position and delete/create items without any reason
1130
598
    if (contentY() < -m_minYExtent) {
1131
599
        return false;
1132
600
    } else if (contentY() + height() > contentHeight()) {
1133
601
        return false;
1134
602
    }
1135
603
    bool changed = false;
1136
604
1137
605
    bool foundVisible = false;
1138
606
    int i = 0;
1139
607
    int removedItems = 0;
1140
608
    const auto oldFirstVisibleIndex = m_firstVisibleIndex;
1141
609
    while (i < m_visibleItems.count()) {
1142
610
        ListItem *item = m_visibleItems[i];
1143
611
        const qreal pos = item->y() + m_clipItem->y();
1144
612
//         qDebug() << i << pos << (pos + item->height()) << bufferFrom << bufferTo;
1145
613
        if (pos + item->height() < bufferFrom || pos > bufferTo) {
1146
614
//             qDebug() << "Releasing" << i << (pos + item->height() < bufferFrom) << pos + item->height() << bufferFrom << (pos > bufferTo) << pos << bufferTo;
1147
615
            releaseItem(item);
1148
616
            m_visibleItems.removeAt(i);
1149
617
            changed = true;
1150
618
            ++removedItems;
1151
619
        } else {
1152
620
            if (!foundVisible) {
1153
621
                foundVisible = true;
1154
622
                const int itemIndex = m_firstVisibleIndex + removedItems + i;
1155
623
                m_firstVisibleIndex = itemIndex;
1156
624
            }
1157
625
            ++i;
1158
626
        }
1159
627
    }
1160
628
    if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1161
629
        adjustMinYExtent();
1162
630
    }
1163
631
1164
632
    return changed;
1165
633
}
1166
634
1167
635
ListViewWithPageHeader::ListItem *ListViewWithPageHeader::createItem(int modelIndex, bool asynchronous)
1168
636
{
1169
637
//     qDebug() << "CREATE ITEM" << modelIndex;
1170
638
    if (asynchronous && m_asyncRequestedIndex != -1)
1171
639
        return nullptr;
1172
640
1173
641
    m_asyncRequestedIndex = -1;
1174
642
    QQuickItem *item = m_delegateModel->item(modelIndex, asynchronous);
1175
643
    if (!item) {
1176
644
        m_asyncRequestedIndex = modelIndex;
1177
645
        return 0;
1178
646
    } else {
1179
647
//         qDebug() << "ListViewWithPageHeader::createItem::We have the item" << modelIndex << item;
1180
648
        ListItem *listItem = new ListItem;
1181
649
        listItem->m_item = item;
1182
650
        listItem->m_sectionItem = getSectionItem(modelIndex, false /*Not yet inserted into m_visibleItems*/);
1183
651
        QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry);
1184
652
        ListItem *prevItem = itemAtIndex(modelIndex - 1);
1185
653
        bool lostItem = false; // Is an item that we requested async but because of model changes
1186
654
                               // it is no longer attached to any of the existing items (has no prev nor next item)
1187
655
                               // nor is the first item
1188
656
        if (prevItem) {
1189
657
            listItem->setY(prevItem->y() + prevItem->height());
1190
658
        } else {
1191
659
            ListItem *currItem = itemAtIndex(modelIndex);
1192
660
            if (currItem) {
1193
661
                // There's something already in m_visibleItems at out index, meaning this is an insert, so attach to its top
1194
662
                listItem->setY(currItem->y() - listItem->height());
1195
663
            } else {
1196
664
                ListItem *nextItem = itemAtIndex(modelIndex + 1);
1197
665
                if (nextItem) {
1198
666
                    listItem->setY(nextItem->y() - listItem->height());
1199
667
                } else if (modelIndex == 0 && m_headerItem) {
1200
668
                    listItem->setY(m_headerItem->height());
1201
669
                } else if (!m_visibleItems.isEmpty()) {
1202
670
                    lostItem = true;
1203
671
                }
1204
672
            }
1205
673
        }
1206
674
        if (lostItem) {
1207
675
            releaseItem(listItem);
1208
676
            listItem = nullptr;
1209
677
        } else {
1210
678
            listItem->setCulled(listItem->y() + listItem->height() + m_clipItem->y() < contentY() || listItem->y() + m_clipItem->y() >= contentY() + height());
1211
679
            if (m_visibleItems.isEmpty()) {
1212
680
                m_visibleItems << listItem;
1213
681
            } else {
1214
682
                m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
1215
683
            }
1216
684
            if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
1217
685
                m_firstVisibleIndex = modelIndex;
1218
686
                polish();
1219
687
            }
1220
688
            adjustMinYExtent();
1221
689
            m_contentHeightDirty = true;
1222
690
        }
1223
691
        return listItem;
1224
692
    }
1225
693
}
1226
694
1227
695
void ListViewWithPageHeader::itemCreated(int modelIndex, QQuickItem *item)
1228
696
{
1229
697
//     qDebug() << "ListViewWithPageHeader::itemCreated" << modelIndex << item;
1230
698
1231
699
    item->setParentItem(m_clipItem);
1232
700
    QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
1233
701
    context->setContextProperty(QLatin1String("ListViewWithPageHeader"), this);
1234
702
    context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
1235
703
    if (modelIndex == m_asyncRequestedIndex) {
1236
704
        createItem(modelIndex, false);
1237
705
        refill();
1238
706
    }
1239
707
}
1240
708
1241
709
void ListViewWithPageHeader::updateClipItem()
1242
710
{
1243
711
    m_clipItem->setHeight(height() - m_headerItemShownHeight);
1244
712
    m_clipItem->setY(contentY() + m_headerItemShownHeight);
1245
713
    m_clipItem->setClip(!m_forceNoClip && m_headerItemShownHeight > 0);
1246
714
}
1247
715
1248
716
void ListViewWithPageHeader::onContentHeightChanged()
1249
717
{
1250
718
    updateClipItem();
1251
719
}
1252
720
1253
721
void ListViewWithPageHeader::onContentWidthChanged()
1254
722
{
1255
723
    m_clipItem->setWidth(contentItem()->width());
1256
724
}
1257
725
1258
726
void ListViewWithPageHeader::onHeightChanged()
1259
727
{
1260
728
    polish();
1261
729
}
1262
730
1263
731
void ListViewWithPageHeader::onModelUpdated(const QQuickChangeSet &changeSet, bool /*reset*/)
1264
732
{
1265
733
    // TODO Do something with reset
1266
734
//     qDebug() << "ListViewWithPageHeader::onModelUpdated" << changeSet << reset;
1267
735
    const auto oldFirstVisibleIndex = m_firstVisibleIndex;
1268
736
1269
737
    Q_FOREACH(const QQuickChangeSet::Remove &remove, changeSet.removes()) {
1270
738
//         qDebug() << "ListViewWithPageHeader::onModelUpdated Remove" << remove.index << remove.count;
1271
739
        if (remove.index + remove.count > m_firstVisibleIndex && remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
1272
740
            const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1273
741
            // If all the items we are removing are either not created or culled
1274
742
            // we have to grow down to avoid viewport changing
1275
743
            bool growDown = true;
1276
744
            for (int i = 0; growDown && i < remove.count; ++i) {
1277
745
                const int modelIndex = remove.index + i;
1278
746
                ListItem *item = itemAtIndex(modelIndex);
1279
747
                if (item && !item->culled()) {
1280
748
                    growDown = false;
1281
749
                }
1282
750
            }
1283
751
            for (int i = remove.count - 1; i >= 0; --i) {
1284
752
                const int visibleIndex = remove.index + i - m_firstVisibleIndex;
1285
753
                if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
1286
754
                    ListItem *item = m_visibleItems[visibleIndex];
1287
755
                    // Pass the section item down if needed
1288
756
                    if (item->m_sectionItem && visibleIndex + 1 < m_visibleItems.count()) {
1289
757
                        ListItem *nextItem = m_visibleItems[visibleIndex + 1];
1290
758
                        if (!nextItem->m_sectionItem) {
1291
759
                            nextItem->m_sectionItem = item->m_sectionItem;
1292
760
                            item->m_sectionItem = nullptr;
1293
761
                        }
1294
762
                    }
1295
763
                    releaseItem(item);
1296
764
                    m_visibleItems.removeAt(visibleIndex);
1297
765
                }
1298
766
            }
1299
767
            if (growDown) {
1300
768
                adjustMinYExtent();
1301
769
            } else if (remove.index <= m_firstVisibleIndex && !m_visibleItems.isEmpty()) {
1302
770
                // We removed the first item that is the one that positions the rest
1303
771
                // position the new first item correctly
1304
772
                m_visibleItems.first()->setY(oldFirstValidIndexPos);
1305
773
            }
1306
774
        } else if (remove.index + remove.count <= m_firstVisibleIndex) {
1307
775
            m_firstVisibleIndex -= remove.count;
1308
776
        }
1309
777
        for (int i = remove.count - 1; i >= 0; --i) {
1310
778
            const int modelIndex = remove.index + i;
1311
779
            if (modelIndex == m_asyncRequestedIndex) {
1312
780
                m_asyncRequestedIndex = -1;
1313
781
            } else if (modelIndex < m_asyncRequestedIndex) {
1314
782
                m_asyncRequestedIndex--;
1315
783
            }
1316
784
        }
1317
785
    }
1318
786
1319
787
    Q_FOREACH(const QQuickChangeSet::Insert &insert, changeSet.inserts()) {
1320
788
//         qDebug() << "ListViewWithPageHeader::onModelUpdated Insert" << insert.index << insert.count;
1321
789
        const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
1322
790
        const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y() + m_clipItem->y() > contentY();
1323
791
        if (insertingInValidIndexes || firstItemWithViewOnTop)
1324
792
        {
1325
793
            // If the items we are adding won't be really visible
1326
794
            // we grow up instead of down to not change the viewport
1327
795
            bool growUp = false;
1328
796
            if (!firstItemWithViewOnTop) {
1329
797
                for (int i = 0; i < m_visibleItems.count(); ++i) {
1330
798
                    if (!m_visibleItems[i]->culled()) {
1331
799
                        if (insert.index <= m_firstVisibleIndex + i) {
1332
800
                            growUp = true;
1333
801
                        }
1334
802
                        break;
1335
803
                    }
1336
804
                }
1337
805
            }
1338
806
1339
807
            const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
1340
808
            for (int i = insert.count - 1; i >= 0; --i) {
1341
809
                const int modelIndex = insert.index + i;
1342
810
                ListItem *item = createItem(modelIndex, false);
1343
811
                if (growUp) {
1344
812
                    ListItem *firstItem = m_visibleItems.first();
1345
813
                    firstItem->setY(firstItem->y() - item->height());
1346
814
                    adjustMinYExtent();
1347
815
                }
1348
816
                // Adding an item may break a "same section" chain, so check
1349
817
                // if we need adding a new section item
1350
818
                if (m_sectionDelegate) {
1351
819
                    ListItem *nextItem = itemAtIndex(modelIndex + 1);
1352
820
                    if (nextItem && !nextItem->m_sectionItem) {
1353
821
                        nextItem->m_sectionItem = getSectionItem(modelIndex + 1, true /* alredy inserted into m_visibleItems*/);
1354
822
                        if (growUp && nextItem->m_sectionItem) {
1355
823
                            ListItem *firstItem = m_visibleItems.first();
1356
824
                            firstItem->setY(firstItem->y() - nextItem->m_sectionItem->height());
1357
825
                            adjustMinYExtent();
1358
826
                        }
1359
827
                    }
1360
828
                }
1361
829
            }
1362
830
            if (firstItemWithViewOnTop) {
1363
831
                ListItem *firstItem = m_visibleItems.first();
1364
832
                firstItem->setY(oldFirstValidIndexPos);
1365
833
            }
1366
834
        } else if (insert.index <= m_firstVisibleIndex) {
1367
835
            m_firstVisibleIndex += insert.count;
1368
836
        }
1369
837
1370
838
        for (int i = insert.count - 1; i >= 0; --i) {
1371
839
            const int modelIndex = insert.index + i;
1372
840
            if (modelIndex <= m_asyncRequestedIndex) {
1373
841
                m_asyncRequestedIndex++;
1374
842
            }
1375
843
        }
1376
844
    }
1377
845
1378
846
    if (m_firstVisibleIndex != oldFirstVisibleIndex) {
1379
847
        adjustMinYExtent();
1380
848
    }
1381
849
1382
850
    layout();
1383
851
    polish();
1384
852
    m_contentHeightDirty = true;
1385
853
}
1386
854
1387
855
void ListViewWithPageHeader::onShowHeaderAnimationFinished()
1388
856
{
1389
857
    m_contentHeightDirty = true;
1390
858
    polish();
1391
859
}
1392
860
1393
861
void ListViewWithPageHeader::itemGeometryChanged(QQuickItem * /*item*/, const QRectF &newGeometry, const QRectF &oldGeometry)
1394
862
{
1395
863
    const qreal heightDiff = newGeometry.height() - oldGeometry.height();
1396
864
    if (heightDiff != 0) {
1397
865
        if (oldGeometry.y() + oldGeometry.height() + m_clipItem->y() < contentY() && !m_visibleItems.isEmpty()) {
1398
866
            ListItem *firstItem = m_visibleItems.first();
1399
867
            firstItem->setY(firstItem->y() - heightDiff);
1400
868
            adjustMinYExtent();
1401
869
            layout();
1402
870
        }
1403
871
        refill();
1404
872
        adjustMinYExtent();
1405
873
        polish();
1406
874
        m_contentHeightDirty = true;
1407
875
    }
1408
876
}
1409
877
1410
878
void ListViewWithPageHeader::headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY)
1411
879
{
1412
880
    const qreal heightDiff = newHeaderHeight - oldHeaderHeight;
1413
881
    if (m_headerItemShownHeight > 0) {
1414
882
        // If the header is shown because of the clip
1415
883
        // Change its size
1416
884
        m_headerItemShownHeight += heightDiff;
1417
885
        m_headerItemShownHeight = qBound(static_cast<qreal>(0.), m_headerItemShownHeight, newHeaderHeight);
1418
886
        updateClipItem();
1419
887
        adjustMinYExtent();
1420
888
    } else {
1421
889
        if (oldHeaderY + oldHeaderHeight > contentY()) {
1422
890
            // If the header is shown because its position
1423
891
            // Change its size
1424
892
            ListItem *firstItem = m_visibleItems.first();
1425
893
            firstItem->setY(firstItem->y() + heightDiff);
1426
894
            layout();
1427
895
        } else {
1428
896
            // If the header is not on screen, just change the start of the list
1429
897
            // so the viewport is not changed
1430
898
            adjustMinYExtent();
1431
899
        }
1432
900
    }
1433
901
}
1434
902
1435
903
1436
904
void ListViewWithPageHeader::adjustMinYExtent()
1437
905
{
1438
906
    if (m_visibleItems.isEmpty()) {
1439
907
        m_minYExtent = 0;
1440
908
    } else {
1441
909
        qreal nonCreatedHeight = 0;
1442
910
        if (m_firstVisibleIndex != 0) {
1443
911
            // Calculate the average height of items to estimate the position of the list start
1444
912
            const int visibleItems = m_visibleItems.count();
1445
913
            qreal visibleItemsHeight = 0;
1446
914
            Q_FOREACH(ListItem *item, m_visibleItems) {
1447
915
                visibleItemsHeight += item->height();
1448
916
            }
1449
917
            nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
1450
918
//             qDebug() << m_firstVisibleIndex << visibleItemsHeight << visibleItems << nonCreatedHeight;
1451
919
        }
1452
920
        m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y() - m_clipItem->y() + (m_headerItem ? m_headerItem->implicitHeight() : 0);
1453
921
    }
1454
922
}
1455
923
1456
924
ListViewWithPageHeader::ListItem *ListViewWithPageHeader::itemAtIndex(int modelIndex) const
1457
925
{
1458
926
    const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
1459
927
    if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
1460
928
        return m_visibleItems[visibleIndexedModelIndex];
1461
929
1462
930
    return nullptr;
1463
931
}
1464
932
1465
933
void ListViewWithPageHeader::layout()
1466
934
{
1467
935
    if (m_inLayout)
1468
936
        return;
1469
937
1470
938
    m_inLayout = true;
1471
939
    if (!m_visibleItems.isEmpty()) {
1472
940
        const qreal visibleFrom = contentY() - m_clipItem->y() + m_headerItemShownHeight;
1473
941
        const qreal visibleTo = contentY() + height() - m_clipItem->y();
1474
942
1475
943
        qreal pos = m_visibleItems.first()->y();
1476
944
1477
945
//         qDebug() << "ListViewWithPageHeader::layout Updating positions and heights. contentY" << contentY() << "minYExtent" << minYExtent();
1478
946
        int firstReallyVisibleItem = -1;
1479
947
        int modelIndex = m_firstVisibleIndex;
1480
948
        Q_FOREACH(ListItem *item, m_visibleItems) {
1481
949
            const bool cull = pos + item->height() < visibleFrom || pos >= visibleTo;
1482
950
            item->setCulled(cull);
1483
951
            item->setY(pos);
1484
952
            if (!cull && firstReallyVisibleItem == -1) {
1485
953
                firstReallyVisibleItem = modelIndex;
1486
954
                if (m_topSectionItem) {
1487
955
                    // Update the top sticky section header
1488
956
                    const QString section = m_delegateModel->stringValue(modelIndex, m_sectionProperty);
1489
957
                    QQmlContext *context = QQmlEngine::contextForObject(m_topSectionItem)->parentContext();
1490
958
                    context->setContextProperty(QLatin1String("section"), section);
1491
959
1492
960
                    // Positing the top section sticky item is a two step process
1493
961
                    // First we set it either we cull it (because it doesn't need to be sticked to the top)
1494
962
                    // or stick it to the top
1495
963
                    // Then after the loop we'll make sure that if there's another section just below it
1496
964
                    // pushed the sticky section up to make it disappear
1497
965
                    const qreal topSectionStickPos = m_headerItemShownHeight + contentY() - m_clipItem->y();
1498
966
                    if (topSectionStickPos <= pos) {
1499
967
                        QQuickItemPrivate::get(m_topSectionItem)->setCulled(true);
1500
968
                        if (item->m_sectionItem) {
1501
969
                            // This seems it should happen since why would we cull the top section
1502
970
                            // if the first visible item has no section header? This only happens briefly
1503
971
                            // when increasing the height of a list that is at the bottom, the m_topSectionItem
1504
972
                            // gets shown shortly in the next polish call
1505
973
                            QQuickItemPrivate::get(item->m_sectionItem)->setCulled(false);
1506
974
                        }
1507
975
                    } else {
1508
976
                        QQuickItemPrivate::get(m_topSectionItem)->setCulled(false);
1509
977
                        m_topSectionItem->setY(topSectionStickPos);
1510
978
                        if (item->m_sectionItem) {
1511
979
                            QQuickItemPrivate::get(item->m_sectionItem)->setCulled(true);
1512
980
                        }
1513
981
                    }
1514
982
                }
1515
983
            }
1516
984
            QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
1517
985
            const qreal clipFrom = visibleFrom + (!item->m_sectionItem && m_topSectionItem && !QQuickItemPrivate::get(m_topSectionItem)->culled ? m_topSectionItem->height() : 0);
1518
986
            if (!cull && pos < clipFrom) {
1519
987
                context->setContextProperty(QLatin1String("heightToClip"), clipFrom - pos);
1520
988
            } else {
1521
989
                context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
1522
990
            }
1523
991
//             qDebug() << "ListViewWithPageHeader::layout" << item->m_item;
1524
992
            pos += item->height();
1525
993
            ++modelIndex;
1526
994
        }
1527
995
1528
996
        // Second step of section sticky item positioning
1529
997
        // Look at the next section header, check if it's pushing up the sticky one
1530
998
        if (m_topSectionItem) {
1531
999
            if (firstReallyVisibleItem >= 0) {
1532
1000
                for (int i = firstReallyVisibleItem - m_firstVisibleIndex + 1; i < m_visibleItems.count(); ++i) {
1533
1001
                    ListItem *item = m_visibleItems[i];
1534
1002
                    if (item->m_sectionItem) {
1535
1003
                        if (m_topSectionItem->y() + m_topSectionItem->height() > item->y()) {
1536
1004
                            m_topSectionItem->setY(item->y() - m_topSectionItem->height());
1537
1005
                        }
1538
1006
                        break;
1539
1007
                    }
1540
1008
                }
1541
1009
            }
1542
1010
        }
1543
1011
    }
1544
1012
    m_inLayout = false;
1545
1013
}
1546
1014
1547
1015
void ListViewWithPageHeader::updatePolish()
1548
1016
{
1549
1017
    Q_FOREACH(ListItem *item, m_itemsToRelease)
1550
1018
        reallyReleaseItem(item);
1551
1019
    m_itemsToRelease.clear();
1552
1020
1553
1021
    if (!model())
1554
1022
        return;
1555
1023
1556
1024
    layout();
1557
1025
1558
1026
    refill();
1559
1027
1560
1028
    if (m_contentHeightDirty) {
1561
1029
        qreal contentHeight;
1562
1030
        if (m_visibleItems.isEmpty()) {
1563
1031
            contentHeight = m_headerItem ? m_headerItem->height() : 0;
1564
1032
        } else {
1565
1033
            const int modelCount = model()->rowCount();
1566
1034
            const int visibleItems = m_visibleItems.count();
1567
1035
            const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
1568
1036
            qreal nonCreatedHeight = 0;
1569
1037
            if (lastValidIndex != modelCount - 1) {
1570
1038
                const int visibleItems = m_visibleItems.count();
1571
1039
                qreal visibleItemsHeight = 0;
1572
1040
                Q_FOREACH(ListItem *item, m_visibleItems) {
1573
1041
                    visibleItemsHeight += item->height();
1574
1042
                }
1575
1043
                const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
1576
1044
                nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
1577
1045
            }
1578
1046
            ListItem *item = m_visibleItems.last();
1579
1047
            contentHeight = nonCreatedHeight + item->y() + item->height() + m_clipItem->y();
1580
1048
            if (m_firstVisibleIndex != 0) {
1581
1049
                // Make sure that if we are shrinking we tell the view we still fit
1582
1050
                m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
1583
1051
            }
1584
1052
        }
1585
1053
1586
1054
        m_contentHeightDirty = false;
1587
1055
        setContentHeight(contentHeight);
1588
1056
    }
1589
1057
}
1590
1058
1591
1059
#include "moc_listviewwithpageheader.cpp"
1592
0
1060
1593
=== added file 'plugins/ListViewWithPageHeader/listviewwithpageheader.h'
1594
--- plugins/ListViewWithPageHeader/listviewwithpageheader.h	1970-01-01 00:00:00 +0000
1595
+++ plugins/ListViewWithPageHeader/listviewwithpageheader.h	2013-07-01 11:23:32 +0000
1596
@@ -0,0 +1,180 @@
1597
1
/*
1598
2
 * Copyright (C) 2013 Canonical, Ltd.
1599
3
 *
1600
4
 * This program is free software; you can redistribute it and/or modify
1601
5
 * it under the terms of the GNU General Public License as published by
1602
6
 * the Free Software Foundation; version 3.
1603
7
 *
1604
8
 * This program is distributed in the hope that it will be useful,
1605
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1606
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1607
11
 * GNU General Public License for more details.
1608
12
 *
1609
13
 * You should have received a copy of the GNU General Public License
1610
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1611
15
 */
1612
16
1613
17
#ifndef LISTVIEWWITHPAGEHEADER_H
1614
18
#define LISTVIEWWITHPAGEHEADER_H
1615
19
1616
20
#include <private/qquickitemchangelistener_p.h>
1617
21
#include <private/qquickflickable_p.h>
1618
22
1619
23
class QAbstractItemModel;
1620
24
class QQuickChangeSet;
1621
25
class QQuickNumberAnimation;
1622
26
class QQuickVisualDataModel;
1623
27
1624
28
1625
29
/**
1626
30
    Note for users of this class
1627
31
1628
32
    ListViewWithPageHeader already loads delegates async when appropiate so if
1629
33
    your delegate uses a Loader you should not enable the asynchronous feature since
1630
34
    that will need to introduce sizing problems
1631
35
1632
36
    With the double async it may happen what while we are scrolling down
1633
37
    we reach to a point where given the size of the just created delegate with loader not yet loaded (which will be very close to 0)
1634
38
    we are already "at the end" of the list, but then a few milliseconds later the loader finishes loading and we could
1635
39
    have kept scrolling. This is specially visible at the end of the list where you realize
1636
40
    that scrolling ended a bit before the end of the list but the speed of the flicking was good
1637
41
    to reach the end
1638
42
1639
43
    By not having the second async we get a better sizing when the delegate is created and things work better
1640
44
*/
1641
45
1642
46
class ListViewWithPageHeader : public QQuickFlickable, public QQuickItemChangeListener
1643
47
{
1644
48
    Q_OBJECT
1645
49
    Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelChanged)
1646
50
    Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY delegateChanged)
1647
51
    Q_PROPERTY(QQuickItem *pageHeader READ header WRITE setHeader NOTIFY headerChanged)
1648
52
    Q_PROPERTY(QQmlComponent *sectionDelegate READ sectionDelegate WRITE setSectionDelegate NOTIFY sectionDelegateChanged)
1649
53
    Q_PROPERTY(QString sectionProperty READ sectionProperty WRITE setSectionProperty NOTIFY sectionPropertyChanged)
1650
54
    Q_PROPERTY(bool forceNoClip READ forceNoClip WRITE setForceNoClip NOTIFY forceNoClipChanged)
1651
55
1652
56
    friend class ListViewWithPageHeaderTest;
1653
57
    friend class ListViewWithPageHeaderTestSection;
1654
58
1655
59
public:
1656
60
    ListViewWithPageHeader();
1657
61
    ~ListViewWithPageHeader();
1658
62
1659
63
    QAbstractItemModel *model() const;
1660
64
    void setModel(QAbstractItemModel *model);
1661
65
1662
66
    QQmlComponent *delegate() const;
1663
67
    void setDelegate(QQmlComponent *delegate);
1664
68
1665
69
    QQuickItem *header() const;
1666
70
    void setHeader(QQuickItem *header);
1667
71
1668
72
    QQmlComponent *sectionDelegate() const;
1669
73
    void setSectionDelegate(QQmlComponent *delegate);
1670
74
1671
75
    QString sectionProperty() const;
1672
76
    void setSectionProperty(const QString &property);
1673
77
1674
78
    bool forceNoClip() const;
1675
79
    void setForceNoClip(bool noClip);
1676
80
1677
81
    Q_INVOKABLE void positionAtBeginning();
1678
82
    Q_INVOKABLE void showHeader();
1679
83
1680
84
Q_SIGNALS:
1681
85
    void modelChanged();
1682
86
    void delegateChanged();
1683
87
    void headerChanged();
1684
88
    void sectionDelegateChanged();
1685
89
    void sectionPropertyChanged();
1686
90
    void forceNoClipChanged();
1687
91
1688
92
protected:
1689
93
    void componentComplete();
1690
94
    void viewportMoved(Qt::Orientations orient);
1691
95
    qreal minYExtent() const;
1692
96
    void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry);
1693
97
    void updatePolish();
1694
98
1695
99
private Q_SLOTS:
1696
100
    void itemCreated(int modelIndex, QQuickItem *item);
1697
101
    void onContentHeightChanged();
1698
102
    void onContentWidthChanged();
1699
103
    void onHeightChanged();
1700
104
    void onModelUpdated(const QQuickChangeSet &changeSet, bool reset);
1701
105
    void onShowHeaderAnimationFinished();
1702
106
1703
107
private:
1704
108
    class ListItem
1705
109
    {
1706
110
        public:
1707
111
            qreal height() const;
1708
112
1709
113
            qreal y() const;
1710
114
            void setY(qreal newY);
1711
115
1712
116
            bool culled() const;
1713
117
            void setCulled(bool culled);
1714
118
1715
119
            QQuickItem *m_item;
1716
120
            QQuickItem *m_sectionItem;
1717
121
    };
1718
122
1719
123
    void createDelegateModel();
1720
124
1721
125
    void layout();
1722
126
    void refill();
1723
127
    bool addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous);
1724
128
    bool removeNonVisibleItems(qreal bufferFrom, qreal bufferTo);
1725
129
    ListItem *createItem(int modelIndex, bool asynchronous);
1726
130
1727
131
    void adjustMinYExtent();
1728
132
    void updateClipItem();
1729
133
    void headerHeightChanged(qreal newHeaderHeight, qreal oldHeaderHeight, qreal oldHeaderY);
1730
134
    ListItem *itemAtIndex(int modelIndex) const; // Returns the item at modelIndex if has been created
1731
135
    void releaseItem(ListItem *item);
1732
136
    void reallyReleaseItem(ListItem *item);
1733
137
    void updateWatchedRoles();
1734
138
    QQuickItem *getSectionItem(int modelIndex, bool alreadyInserted);
1735
139
    QQuickItem *getSectionItem(const QString &sectionText);
1736
140
1737
141
    QQuickVisualDataModel *m_delegateModel;
1738
142
1739
143
    // Index we are waiting because we requested it asynchronously
1740
144
    int m_asyncRequestedIndex;
1741
145
1742
146
    // Used to only give a warning once if the delegate does not return objects
1743
147
    bool m_delegateValidated;
1744
148
1745
149
    // Visible indexes, [0] is m_firstValidIndex, [0+1] is m_firstValidIndex +1, ...
1746
150
    QList<ListItem *> m_visibleItems;
1747
151
    int m_firstVisibleIndex;
1748
152
1749
153
    qreal m_minYExtent;
1750
154
1751
155
    QQuickItem *m_clipItem;
1752
156
1753
157
    // If any of the heights has changed
1754
158
    // or new items have been added/removed
1755
159
    bool m_contentHeightDirty;
1756
160
1757
161
    QQuickItem *m_headerItem;
1758
162
    qreal m_previousContentY;
1759
163
    qreal m_headerItemShownHeight; // The height of header shown when the header is shown outside its topmost position
1760
164
                                   // i.e. it's being shown after dragging down in the middle of the list
1761
165
    QQuickNumberAnimation *m_headerShowAnimation;
1762
166
1763
167
    QQmlComponent *m_sectionDelegate;
1764
168
    QString m_sectionProperty;
1765
169
    QQuickItem *m_topSectionItem;
1766
170
1767
171
    bool m_forceNoClip;
1768
172
    bool m_inLayout;
1769
173
1770
174
    // Qt 5.0 doesn't like releasing the items just after itemCreated
1771
175
    // so we delay the releasing until the next updatePolish
1772
176
    QList<ListItem *> m_itemsToRelease;
1773
177
};
1774
178
1775
179
1776
180
#endif
1777
0
181
1778
=== added file 'plugins/ListViewWithPageHeader/plugin.cpp'
1779
--- plugins/ListViewWithPageHeader/plugin.cpp	1970-01-01 00:00:00 +0000
1780
+++ plugins/ListViewWithPageHeader/plugin.cpp	2013-07-01 11:23:32 +0000
1781
@@ -0,0 +1,29 @@
1782
1
/*
1783
2
 * Copyright (C) 2013 Canonical, Ltd.
1784
3
 *
1785
4
 * This program is free software; you can redistribute it and/or modify
1786
5
 * it under the terms of the GNU General Public License as published by
1787
6
 * the Free Software Foundation; version 3.
1788
7
 *
1789
8
 * This program is distributed in the hope that it will be useful,
1790
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1791
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1792
11
 * GNU General Public License for more details.
1793
12
 *
1794
13
 * You should have received a copy of the GNU General Public License
1795
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1796
15
 *
1797
16
 */
1798
17
1799
18
#include "plugin.h"
1800
19
1801
20
#include "listviewwithpageheader.h"
1802
21
1803
22
#include <QAbstractItemModel>
1804
23
1805
24
void ListViewWithPageHeaderPlugin::registerTypes(const char *uri)
1806
25
{
1807
26
    Q_ASSERT(uri == QLatin1String("ListViewWithPageHeader"));
1808
27
    qmlRegisterType<QAbstractItemModel>();
1809
28
    qmlRegisterType<ListViewWithPageHeader>(uri, 0, 1, "ListViewWithPageHeader");
1810
29
}
1811
0
30
1812
=== added file 'plugins/ListViewWithPageHeader/plugin.h'
1813
--- plugins/ListViewWithPageHeader/plugin.h	1970-01-01 00:00:00 +0000
1814
+++ plugins/ListViewWithPageHeader/plugin.h	2013-07-01 11:23:32 +0000
1815
@@ -0,0 +1,33 @@
1816
1
/*
1817
2
 * Copyright (C) 2012 Canonical, Ltd.
1818
3
 *
1819
4
 * This program is free software; you can redistribute it and/or modify
1820
5
 * it under the terms of the GNU General Public License as published by
1821
6
 * the Free Software Foundation; version 3.
1822
7
 *
1823
8
 * This program is distributed in the hope that it will be useful,
1824
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1825
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1826
11
 * GNU General Public License for more details.
1827
12
 *
1828
13
 * You should have received a copy of the GNU General Public License
1829
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1830
15
 *
1831
16
 */
1832
17
1833
18
#ifndef LISTVIEWWITHPAGEHEADER_PLUGIN_H
1834
19
#define LISTVIEWWITHPAGEHEADER_PLUGIN_H
1835
20
1836
21
#include <QtQml/QQmlEngine>
1837
22
#include <QtQml/QQmlExtensionPlugin>
1838
23
1839
24
class ListViewWithPageHeaderPlugin : public QQmlExtensionPlugin
1840
25
{
1841
26
    Q_OBJECT
1842
27
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
1843
28
1844
29
public:
1845
30
    void registerTypes(const char *uri);
1846
31
};
1847
32
1848
33
#endif
1849
0
34
1850
=== added file 'plugins/ListViewWithPageHeader/qmldir'
1851
--- plugins/ListViewWithPageHeader/qmldir	1970-01-01 00:00:00 +0000
1852
+++ plugins/ListViewWithPageHeader/qmldir	2013-07-01 11:23:32 +0000
1853
@@ -0,0 +1,2 @@
1854
1
module ListViewWithPageHeader
1855
2
plugin ListViewWithPageHeader-qml
1856
0
3
1857
=== modified file 'run_on_device'
1858
--- run_on_device	2013-06-24 11:08:38 +0000
1859
+++ run_on_device	2013-07-01 11:23:32 +0000
1860
@@ -75,7 +75,7 @@
1861
75
sync_code() {
75
sync_code() {
1862
76
    [ -e .bzr ] && bzr export --uncommitted --format=dir /tmp/$CODE_DIR
76
    [ -e .bzr ] && bzr export --uncommitted --format=dir /tmp/$CODE_DIR
1863
77
    [ -e .git ] && git checkout-index -a -f --prefix=/tmp/$CODE_DIR/
77
    [ -e .git ] && git checkout-index -a -f --prefix=/tmp/$CODE_DIR/
1865
78
    rsync -crlOzv -e "ssh -p $TARGET_SSH_PORT -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" /tmp/$CODE_DIR/ $USER@$TARGET_IP:$CODE_DIR/
78
    rsync -crlOzv --delete --exclude builddir -e "ssh -p $TARGET_SSH_PORT -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" /tmp/$CODE_DIR/ $USER@$TARGET_IP:$CODE_DIR/
1866
79
    rm -rf /tmp/$CODE_DIR
79
    rm -rf /tmp/$CODE_DIR
1867
80
}
80
}
1868
81
81
1869
82
82
1870
=== modified file 'tests/plugins/CMakeLists.txt'
1871
--- tests/plugins/CMakeLists.txt	2013-06-05 22:03:08 +0000
1872
+++ tests/plugins/CMakeLists.txt	2013-07-01 11:23:32 +0000
1873
@@ -1,2 +1,3 @@
1874
1
add_subdirectory(Utils)
1
add_subdirectory(Utils)
1875
2
add_subdirectory(Ubuntu)
2
add_subdirectory(Ubuntu)
1876
3
add_subdirectory(ListViewWithPageHeader)
1877
3
4
1878
=== added directory 'tests/plugins/ListViewWithPageHeader'
1879
=== added file 'tests/plugins/ListViewWithPageHeader/CMakeLists.txt'
1880
--- tests/plugins/ListViewWithPageHeader/CMakeLists.txt	1970-01-01 00:00:00 +0000
1881
+++ tests/plugins/ListViewWithPageHeader/CMakeLists.txt	2013-07-01 11:23:32 +0000
1882
@@ -0,0 +1,31 @@
1883
1
# There's no cmake var for v8 include path :-/
1884
2
# so create one
1885
3
LIST(GET Qt5Core_INCLUDE_DIRS 0 QtCoreDir0)
1886
4
SET(Qt5V8_PRIVATE_INCLUDE_DIR ${QtCoreDir0}/../QtV8/${Qt5Core_VERSION_STRING}/QtV8)
1887
5
1888
6
include_directories(
1889
7
    ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
1890
8
    ${Qt5Quick_INCLUDE_DIRS}
1891
9
    ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
1892
10
    ${Qt5V8_PRIVATE_INCLUDE_DIR}
1893
11
    ${CMAKE_CURRENT_SOURCE_DIR}/../../../plugins/ListViewWithPageHeader
1894
12
    ${CMAKE_CURRENT_BINARY_DIR}
1895
13
    )
1896
14
1897
15
remove_definitions(-DQT_NO_KEYWORDS)
1898
16
1899
17
add_definitions(-DLISTVIEWWITHPAGEHEADER_FOLDER="${CMAKE_CURRENT_SOURCE_DIR}")
1900
18
add_definitions(-DBUILT_PLUGINS_DIR="${CMAKE_BINARY_DIR}/plugins")
1901
19
1902
20
add_executable(listviewwithpageheadertestExec listviewwithpageheadertest.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../plugins/ListViewWithPageHeader/listviewwithpageheader.cpp)
1903
21
qt5_use_modules(listviewwithpageheadertestExec Test Core Qml)
1904
22
target_link_libraries(listviewwithpageheadertestExec ${Qt5Gui_LIBRARIES} ${Qt5Quick_LIBRARIES})
1905
23
add_custom_target(testlistviewwithpageheader ${CMAKE_CURRENT_BINARY_DIR}/listviewwithpageheadertestExec -o ${CMAKE_BINARY_DIR}/testlistviewwithpageheader.xml,xunitxml -o -,txt)
1906
24
1907
25
add_executable(listviewwithpageheadertestsectionExec listviewwithpageheadertestsection.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../plugins/ListViewWithPageHeader/listviewwithpageheader.cpp)
1908
26
qt5_use_modules(listviewwithpageheadertestsectionExec Test Core Qml)
1909
27
target_link_libraries(listviewwithpageheadertestsectionExec ${Qt5Gui_LIBRARIES} ${Qt5Quick_LIBRARIES})
1910
28
add_custom_target(testlistviewwithpageheadersection ${CMAKE_CURRENT_BINARY_DIR}/listviewwithpageheadertestsectionExec -o ${CMAKE_BINARY_DIR}/testlistviewwithpageheadersection.xml,xunitxml -o -,txt)
1911
29
1912
30
add_dependencies(qmluitests testlistviewwithpageheader)
1913
31
add_dependencies(qmluitests testlistviewwithpageheadersection)
1914
0
32
1915
=== added file 'tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp'
1916
--- tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp	1970-01-01 00:00:00 +0000
1917
+++ tests/plugins/ListViewWithPageHeader/listviewwithpageheadertest.cpp	2013-07-01 11:23:32 +0000
1918
@@ -0,0 +1,1311 @@
1919
1
/*
1920
2
 * Copyright (C) 2013 Canonical, Ltd.
1921
3
 *
1922
4
 * This program is free software; you can redistribute it and/or modify
1923
5
 * it under the terms of the GNU General Public License as published by
1924
6
 * the Free Software Foundation; version 3.
1925
7
 *
1926
8
 * This program is distributed in the hope that it will be useful,
1927
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1928
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1929
11
 * GNU General Public License for more details.
1930
12
 *
1931
13
 * You should have received a copy of the GNU General Public License
1932
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1933
15
 */
1934
16
1935
17
#include "listviewwithpageheader.h"
1936
18
1937
19
#include <QAbstractItemModel>
1938
20
#include <QQmlEngine>
1939
21
#include <QQuickView>
1940
22
#include <QtTestGui>
1941
23
#include <private/qquicklistmodel_p.h>
1942
24
#include <private/qquickanimation_p.h>
1943
25
#include <private/qquickitem_p.h>
1944
26
1945
27
class ListViewWithPageHeaderTest : public QObject
1946
28
{
1947
29
    Q_OBJECT
1948
30
1949
31
private:
1950
32
    void verifyItem(int visibleIndex, qreal pos, qreal height, bool culled)
1951
33
    {
1952
34
        ListViewWithPageHeader::ListItem *item = lvwph->m_visibleItems[visibleIndex];
1953
35
        QTRY_COMPARE(item->y(), pos);
1954
36
        QTRY_COMPARE(item->height(), height);
1955
37
        QCOMPARE(QQuickItemPrivate::get(item->m_item)->culled, culled);
1956
38
    }
1957
39
1958
40
    void changeContentY(qreal change)
1959
41
    {
1960
42
        const qreal dest = lvwph->contentY() + change;
1961
43
        if (dest > lvwph->contentY()) {
1962
44
            const qreal jump = 25;
1963
45
            while (lvwph->contentY() + jump < dest) {
1964
46
                lvwph->setContentY(lvwph->contentY() + jump);
1965
47
                QTest::qWait(1);
1966
48
            }
1967
49
        } else {
1968
50
            const qreal jump = -25;
1969
51
            while (lvwph->contentY() + jump > dest) {
1970
52
                lvwph->setContentY(lvwph->contentY() + jump);
1971
53
                QTest::qWait(1);
1972
54
            }
1973
55
        }
1974
56
        lvwph->setContentY(dest);
1975
57
        QTest::qWait(1);
1976
58
    }
1977
59
1978
60
    void scrollToTop()
1979
61
    {
1980
62
        const qreal jump = -25;
1981
63
        while (!lvwph->isAtYBeginning()) {
1982
64
            if (lvwph->contentY() + jump > -lvwph->minYExtent()) {
1983
65
                lvwph->setContentY(lvwph->contentY() + jump);
1984
66
            } else {
1985
67
                lvwph->setContentY(lvwph->contentY() - 1);
1986
68
            }
1987
69
            QTest::qWait(1);
1988
70
        }
1989
71
    }
1990
72
1991
73
    void scrollToBottom()
1992
74
    {
1993
75
        const qreal jump = 25;
1994
76
        while (!lvwph->isAtYEnd()) {
1995
77
            if (lvwph->contentY() + lvwph->height() + jump < lvwph->contentHeight()) {
1996
78
                lvwph->setContentY(lvwph->contentY() + jump);
1997
79
            } else {
1998
80
                lvwph->setContentY(lvwph->contentY() + 1);
1999
81
            }
2000
82
            QTest::qWait(1);
2001
83
        }
2002
84
    }
2003
85
2004
86
    void verifyInitialTopPosition()
2005
87
    {
2006
88
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2007
89
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2008
90
        verifyItem(0, 50., 150., false);
2009
91
        verifyItem(1, 200., 200., false);
2010
92
        verifyItem(2, 400., 350., false);
2011
93
        verifyItem(3, 750., 350., true);
2012
94
        QCOMPARE(lvwph->m_minYExtent, 0.);
2013
95
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2014
96
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2015
97
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2016
98
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2017
99
        QCOMPARE(lvwph->contentY(), 0.);
2018
100
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2019
101
    }
2020
102
2021
103
private Q_SLOTS:
2022
104
2023
105
    void initTestCase()
2024
106
    {
2025
107
    }
2026
108
2027
109
    void init()
2028
110
    {
2029
111
        view = new QQuickView();
2030
112
        view->engine()->addImportPath(BUILT_PLUGINS_DIR);
2031
113
        view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test.qml"));
2032
114
        lvwph = dynamic_cast<ListViewWithPageHeader*>(view->rootObject()->findChild<QQuickFlickable*>());
2033
115
        model = view->rootObject()->findChild<QQuickListModel*>();
2034
116
        otherDelegate = view->rootObject()->findChild<QQmlComponent*>();
2035
117
        QVERIFY(lvwph);
2036
118
        QVERIFY(model);
2037
119
        QVERIFY(otherDelegate);
2038
120
        view->show();
2039
121
        QTest::qWaitForWindowExposed(view);
2040
122
2041
123
        verifyInitialTopPosition();
2042
124
    }
2043
125
2044
126
    void cleanup()
2045
127
    {
2046
128
        delete view;
2047
129
    }
2048
130
2049
131
    void testCreationDeletion()
2050
132
    {
2051
133
        // Nothing, init/cleanup already tests this
2052
134
    }
2053
135
2054
136
    void testDrag1PixelUp()
2055
137
    {
2056
138
        lvwph->setContentY(lvwph->contentY() + 1);
2057
139
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2058
140
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2059
141
        verifyItem(0, 49., 150., false);
2060
142
        verifyItem(1, 199., 200., false);
2061
143
        verifyItem(2, 399., 350., false);
2062
144
        verifyItem(3, 749., 350., true);
2063
145
        QCOMPARE(lvwph->m_minYExtent, 0.);
2064
146
        QCOMPARE(lvwph->m_clipItem->y(), 1.);
2065
147
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2066
148
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2067
149
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2068
150
        QCOMPARE(lvwph->contentY(), 1.);
2069
151
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2070
152
    }
2071
153
2072
154
    void testHeaderDetachDragDown()
2073
155
    {
2074
156
        QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));
2075
157
        QTest::qWait(100);
2076
158
        QTest::mouseMove(view, QPoint(0, 5));
2077
159
        QTest::qWait(100);
2078
160
        QTest::mouseMove(view, QPoint(0, 10));
2079
161
        QTest::qWait(100);
2080
162
        QTest::mouseMove(view, QPoint(0, 15));
2081
163
        QTest::qWait(100);
2082
164
        QTest::mouseMove(view, QPoint(0, 20));
2083
165
        QTest::qWait(100);
2084
166
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2085
167
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2086
168
        verifyItem(0, 55., 150., false);
2087
169
        verifyItem(1, 205., 200., false);
2088
170
        verifyItem(2, 405., 350., false);
2089
171
        verifyItem(3, 755., 350., true);
2090
172
        QCOMPARE(lvwph->m_minYExtent, 0.);
2091
173
        QCOMPARE(lvwph->m_clipItem->y(), -5.);
2092
174
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2093
175
        QCOMPARE(lvwph->m_headerItem->y(), -5.);
2094
176
        QCOMPARE(lvwph->m_headerItem->height(), 55.);
2095
177
        QCOMPARE(lvwph->contentY(), -5.);
2096
178
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2097
179
2098
180
        QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));
2099
181
2100
182
        verifyInitialTopPosition();
2101
183
    }
2102
184
2103
185
    void testDrag375PixelUp()
2104
186
    {
2105
187
        changeContentY(375);
2106
188
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2107
189
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2108
190
        verifyItem(0, -325., 150., true);
2109
191
        verifyItem(1, -175, 200., false);
2110
192
        verifyItem(2, 25, 350., false);
2111
193
        verifyItem(3, 375, 350., false);
2112
194
        verifyItem(4, 725, 350., true);
2113
195
        QCOMPARE(lvwph->m_minYExtent, 0.);
2114
196
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
2115
197
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2116
198
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2117
199
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2118
200
        QCOMPARE(lvwph->contentY(), 375.);
2119
201
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2120
202
    }
2121
203
2122
204
    void testDrag520PixelUp()
2123
205
    {
2124
206
        changeContentY(520);
2125
207
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2126
208
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2127
209
        verifyItem(0, -320., 200., true);
2128
210
        verifyItem(1, -120, 350., false);
2129
211
        verifyItem(2, 230, 350., false);
2130
212
        verifyItem(3, 580, 350., true);
2131
213
        // Just here as first check against m_minYExtent when m_firstVisibleIndex is not 0
2132
214
        // We as humans know that m_minYExtent will be 0 but since the first delegate is not there anymore
2133
215
        // we have to estimate its size, the average item height is 312.5 which is 162.5 more than the
2134
216
        // "real" size of 150 and that's why the m_minYExtent has that "peculiar" value
2135
217
        // It's fine since what it means is that we could scroll more up than the original position
2136
218
        // but we will recalculate m_minYExtent when the item 0 is created and set it correctly
2137
219
        QCOMPARE(lvwph->m_minYExtent, 162.5);
2138
220
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2139
221
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2140
222
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2141
223
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2142
224
        QCOMPARE(lvwph->contentY(), 520.);
2143
225
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2144
226
    }
2145
227
2146
228
    void testDragHeaderUpThenShow()
2147
229
    {
2148
230
        changeContentY(120);
2149
231
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2150
232
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2151
233
        verifyItem(0, -70., 150., false);
2152
234
        verifyItem(1, 80., 200., false);
2153
235
        verifyItem(2, 280., 350., false);
2154
236
        verifyItem(3, 630., 350., true);
2155
237
        QCOMPARE(lvwph->m_minYExtent, 0.);
2156
238
        QCOMPARE(lvwph->m_clipItem->y(), 120.);
2157
239
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2158
240
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2159
241
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2160
242
        QCOMPARE(lvwph->contentY(), 120.);
2161
243
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2162
244
2163
245
        changeContentY(-30);
2164
246
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2165
247
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2166
248
        verifyItem(0, -70., 150., false);
2167
249
        verifyItem(1, 80., 200., false);
2168
250
        verifyItem(2, 280., 350., false);
2169
251
        verifyItem(3, 630., 350., true);
2170
252
        QCOMPARE(lvwph->m_minYExtent, 0.);
2171
253
        QCOMPARE(lvwph->m_clipItem->y(), 120.);
2172
254
        QCOMPARE(lvwph->m_clipItem->clip(), true);
2173
255
        QTRY_COMPARE(lvwph->m_headerItem->y(), 70.);
2174
256
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2175
257
        QCOMPARE(lvwph->contentY(), 90.);
2176
258
        QCOMPARE(lvwph->m_headerItemShownHeight, 30.);
2177
259
    }
2178
260
2179
261
    void testDragHeaderUpThenShowWithoutHidingTotally()
2180
262
    {
2181
263
        changeContentY(10);
2182
264
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2183
265
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2184
266
        verifyItem(0, 40., 150., false);
2185
267
        verifyItem(1, 190., 200., false);
2186
268
        verifyItem(2, 390., 350., false);
2187
269
        verifyItem(3, 740., 350., true);
2188
270
        QCOMPARE(lvwph->m_minYExtent, 0.);
2189
271
        QCOMPARE(lvwph->m_clipItem->y(), 10.);
2190
272
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2191
273
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2192
274
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2193
275
        QCOMPARE(lvwph->contentY(), 10.);
2194
276
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2195
277
2196
278
        changeContentY(-1);
2197
279
2198
280
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2199
281
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2200
282
        verifyItem(0, 41., 150., false);
2201
283
        verifyItem(1, 191., 200., false);
2202
284
        verifyItem(2, 391., 350., false);
2203
285
        verifyItem(3, 741., 350., true);
2204
286
        QCOMPARE(lvwph->m_minYExtent, 0.);
2205
287
        QCOMPARE(lvwph->m_clipItem->y(), 9.);
2206
288
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2207
289
        QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);
2208
290
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2209
291
        QCOMPARE(lvwph->contentY(), 9.);
2210
292
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2211
293
    }
2212
294
2213
295
    void testPositionAtBeginningIndex0Visible()
2214
296
    {
2215
297
        changeContentY(375);
2216
298
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2217
299
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2218
300
        verifyItem(0, -325., 150., true);
2219
301
        verifyItem(1, -175, 200., false);
2220
302
        verifyItem(2, 25, 350., false);
2221
303
        verifyItem(3, 375, 350., false);
2222
304
        verifyItem(4, 725, 350., true);
2223
305
        QCOMPARE(lvwph->m_minYExtent, 0.);
2224
306
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
2225
307
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2226
308
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2227
309
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2228
310
        QCOMPARE(lvwph->contentY(), 375.);
2229
311
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2230
312
2231
313
        lvwph->positionAtBeginning();
2232
314
2233
315
        verifyInitialTopPosition();
2234
316
    }
2235
317
2236
318
    void testPositionAtBeginningIndex0NotVisible()
2237
319
    {
2238
320
        changeContentY(520);
2239
321
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2240
322
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2241
323
        verifyItem(0, -320., 200., true);
2242
324
        verifyItem(1, -120, 350., false);
2243
325
        verifyItem(2, 230, 350., false);
2244
326
        verifyItem(3, 580, 350., true);
2245
327
        QCOMPARE(lvwph->m_minYExtent, 162.5);
2246
328
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2247
329
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2248
330
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2249
331
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2250
332
        QCOMPARE(lvwph->contentY(), 520.);
2251
333
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2252
334
2253
335
        lvwph->positionAtBeginning();
2254
336
2255
337
        verifyInitialTopPosition();
2256
338
    }
2257
339
2258
340
    void testIndex0GrowOnScreen()
2259
341
    {
2260
342
        model->setProperty(0, "size", 400);
2261
343
2262
344
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2263
345
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2264
346
        verifyItem(0, 50., 400., false);
2265
347
        verifyItem(1, 450., 200., false);
2266
348
        verifyItem(2, 650., 350., true);
2267
349
        QCOMPARE(lvwph->m_minYExtent, 0.);
2268
350
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2269
351
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2270
352
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2271
353
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2272
354
        QCOMPARE(lvwph->contentY(), 0.);
2273
355
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2274
356
    }
2275
357
2276
358
    void testIndex0GrowOffScreen()
2277
359
    {
2278
360
        changeContentY(375);
2279
361
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2280
362
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2281
363
        verifyItem(0, -325., 150., true);
2282
364
        verifyItem(1, -175, 200., false);
2283
365
        verifyItem(2, 25, 350., false);
2284
366
        verifyItem(3, 375, 350., false);
2285
367
        verifyItem(4, 725, 350., true);
2286
368
        QCOMPARE(lvwph->m_minYExtent, 0.);
2287
369
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
2288
370
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2289
371
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2290
372
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2291
373
        QCOMPARE(lvwph->contentY(), 375.);
2292
374
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2293
375
2294
376
        model->setProperty(0, "size", 400);
2295
377
2296
378
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2297
379
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2298
380
        verifyItem(0, -575., 400., true);
2299
381
        verifyItem(1, -175, 200., false);
2300
382
        verifyItem(2, 25, 350., false);
2301
383
        verifyItem(3, 375, 350., false);
2302
384
        verifyItem(4, 725, 350., true);
2303
385
        QCOMPARE(lvwph->m_minYExtent, 250.);
2304
386
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
2305
387
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2306
388
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2307
389
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2308
390
        QCOMPARE(lvwph->contentY(), 375.);
2309
391
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2310
392
2311
393
        scrollToTop();
2312
394
2313
395
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2314
396
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2315
397
        verifyItem(0, 50., 400., false);
2316
398
        verifyItem(1, 450, 200., false);
2317
399
        verifyItem(2, 650, 350., true);
2318
400
        QCOMPARE(lvwph->m_minYExtent, 250.);
2319
401
        QCOMPARE(lvwph->m_clipItem->y(), -250.);
2320
402
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2321
403
        QCOMPARE(lvwph->m_headerItem->y(), -250.);
2322
404
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2323
405
        QCOMPARE(lvwph->contentY(), -250.);
2324
406
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2325
407
2326
408
        changeContentY(30);
2327
409
2328
410
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2329
411
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2330
412
        verifyItem(0, 20., 400., false);
2331
413
        verifyItem(1, 420, 200., false);
2332
414
        verifyItem(2, 620, 350., true);
2333
415
        QCOMPARE(lvwph->m_minYExtent, 250.);
2334
416
        QCOMPARE(lvwph->m_clipItem->y(), -220.);
2335
417
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2336
418
        QCOMPARE(lvwph->m_headerItem->y(), -250.);
2337
419
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2338
420
        QCOMPARE(lvwph->contentY(), -220.);
2339
421
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2340
422
    }
2341
423
2342
424
    void testIndex0GrowNotCreated()
2343
425
    {
2344
426
        changeContentY(520);
2345
427
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2346
428
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2347
429
        verifyItem(0, -320., 200., true);
2348
430
        verifyItem(1, -120, 350., false);
2349
431
        verifyItem(2, 230, 350., false);
2350
432
        verifyItem(3, 580, 350., true);
2351
433
        QCOMPARE(lvwph->m_minYExtent, 162.5);
2352
434
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2353
435
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2354
436
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2355
437
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2356
438
        QCOMPARE(lvwph->contentY(), 520.);
2357
439
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2358
440
2359
441
        model->setProperty(0, "size", 400);
2360
442
2361
443
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2362
444
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2363
445
        verifyItem(0, -320., 200., true);
2364
446
        verifyItem(1, -120, 350., false);
2365
447
        verifyItem(2, 230, 350., false);
2366
448
        verifyItem(3, 580, 350., true);
2367
449
        QCOMPARE(lvwph->m_minYExtent, 162.5);
2368
450
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2369
451
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2370
452
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2371
453
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2372
454
        QCOMPARE(lvwph->contentY(), 520.);
2373
455
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2374
456
2375
457
        scrollToTop();
2376
458
2377
459
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2378
460
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2379
461
        verifyItem(0, 50., 400., false);
2380
462
        verifyItem(1, 450, 200., false);
2381
463
        verifyItem(2, 650, 350., true);
2382
464
        QCOMPARE(lvwph->m_minYExtent, 250.);
2383
465
        QCOMPARE(lvwph->m_clipItem->y(), -250.);
2384
466
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2385
467
        QCOMPARE(lvwph->m_headerItem->y(), -250.);
2386
468
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2387
469
        QCOMPARE(lvwph->contentY(), -250.);
2388
470
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2389
471
    }
2390
472
2391
473
    void testShowHideShowHeaderAtBottom()
2392
474
    {
2393
475
        scrollToBottom();
2394
476
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2395
477
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2396
478
        verifyItem(0, -508., 350., true);
2397
479
        verifyItem(1, -158, 350., false);
2398
480
        verifyItem(2, 192, 350., false);
2399
481
        QCOMPARE(lvwph->m_minYExtent, 350.);
2400
482
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2401
483
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2402
484
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2403
485
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2404
486
        QCOMPARE(lvwph->contentY(), 1258.);
2405
487
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2406
488
2407
489
        changeContentY(-30);
2408
490
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2409
491
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2410
492
        verifyItem(0, -508., 350., true);
2411
493
        verifyItem(1, -158, 350., false);
2412
494
        verifyItem(2, 192, 350., false);
2413
495
        QCOMPARE(lvwph->m_minYExtent, 350.);
2414
496
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2415
497
        QCOMPARE(lvwph->m_clipItem->clip(), true);
2416
498
        QCOMPARE(lvwph->m_headerItem->y(), 1208.);
2417
499
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2418
500
        QCOMPARE(lvwph->contentY(), 1228.);
2419
501
        QCOMPARE(lvwph->m_headerItemShownHeight, 30.);
2420
502
2421
503
        changeContentY(30);
2422
504
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2423
505
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2424
506
        verifyItem(0, -508., 350., true);
2425
507
        verifyItem(1, -158, 350., false);
2426
508
        verifyItem(2, 192, 350., false);
2427
509
        QCOMPARE(lvwph->m_minYExtent, 350.);
2428
510
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2429
511
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2430
512
        QCOMPARE(lvwph->m_headerItem->y(), -350.);
2431
513
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2432
514
        QCOMPARE(lvwph->contentY(), 1258.);
2433
515
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2434
516
2435
517
        changeContentY(-30);
2436
518
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2437
519
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2438
520
        verifyItem(0, -508., 350., true);
2439
521
        verifyItem(1, -158, 350., false);
2440
522
        verifyItem(2, 192, 350., false);
2441
523
        QCOMPARE(lvwph->m_minYExtent, 350.);
2442
524
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2443
525
        QCOMPARE(lvwph->m_clipItem->clip(), true);
2444
526
        QCOMPARE(lvwph->m_headerItem->y(), 1208.);
2445
527
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2446
528
        QCOMPARE(lvwph->contentY(), 1228.);
2447
529
        QCOMPARE(lvwph->m_headerItemShownHeight, 30.);
2448
530
    }
2449
531
2450
532
    void testChangeDelegateAtBottom()
2451
533
    {
2452
534
        scrollToBottom();
2453
535
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2454
536
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2455
537
        verifyItem(0, -508., 350., true);
2456
538
        verifyItem(1, -158, 350., false);
2457
539
        verifyItem(2, 192, 350., false);
2458
540
        QCOMPARE(lvwph->m_minYExtent, 350.);
2459
541
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2460
542
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2461
543
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2462
544
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2463
545
        QCOMPARE(lvwph->contentY(), 1258.);
2464
546
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2465
547
2466
548
        lvwph->setDelegate(otherDelegate);
2467
549
2468
550
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);
2469
551
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2470
552
        verifyItem(0, 50., 35., false);
2471
553
        verifyItem(1, 85, 35., false);
2472
554
        verifyItem(2, 120, 35., false);
2473
555
        verifyItem(3, 155, 35., false);
2474
556
        verifyItem(4, 190, 35., false);
2475
557
        verifyItem(5, 225, 35., false);
2476
558
        QCOMPARE(lvwph->m_minYExtent, 0.);
2477
559
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2478
560
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2479
561
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2480
562
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2481
563
        QCOMPARE(lvwph->contentY(), 0.);
2482
564
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2483
565
    }
2484
566
2485
567
    void testSetEmptyHeaderAtTop()
2486
568
    {
2487
569
        lvwph->setHeader(nullptr);
2488
570
2489
571
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2490
572
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2491
573
        verifyItem(0, 0., 150., false);
2492
574
        verifyItem(1, 150., 200., false);
2493
575
        verifyItem(2, 350., 350., false);
2494
576
        verifyItem(3, 700., 350., true);
2495
577
        QCOMPARE(lvwph->m_minYExtent, 0.);
2496
578
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2497
579
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2498
580
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
2499
581
        QCOMPARE(lvwph->contentY(), 0.);
2500
582
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2501
583
    }
2502
584
2503
585
    void testSetEmptyHeaderAtBottom()
2504
586
    {
2505
587
        scrollToBottom();
2506
588
        lvwph->setHeader(nullptr);
2507
589
2508
590
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2509
591
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2510
592
        verifyItem(0, -508., 350., true);
2511
593
        verifyItem(1, -158, 350., false);
2512
594
        verifyItem(2, 192, 350., false);
2513
595
        QCOMPARE(lvwph->m_minYExtent, 300.);
2514
596
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2515
597
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2516
598
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
2517
599
        QCOMPARE(lvwph->contentY(), 1258.);
2518
600
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2519
601
2520
602
        scrollToTop();
2521
603
2522
604
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2523
605
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2524
606
        verifyItem(0, 0., 150., false);
2525
607
        verifyItem(1, 150., 200., false);
2526
608
        verifyItem(2, 350., 350., false);
2527
609
        verifyItem(3, 700., 350., true);
2528
610
        QCOMPARE(lvwph->m_minYExtent, -50.);
2529
611
        QCOMPARE(lvwph->m_clipItem->y(), 50.);
2530
612
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2531
613
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
2532
614
        QCOMPARE(lvwph->contentY(), 50.);
2533
615
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2534
616
    }
2535
617
2536
618
    void testSetEmptyHeaderWhenPartlyShownClipped()
2537
619
    {
2538
620
        scrollToBottom();
2539
621
        changeContentY(-30);
2540
622
        lvwph->setHeader(nullptr);
2541
623
2542
624
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2543
625
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2544
626
        verifyItem(0, -508., 350., true);
2545
627
        verifyItem(1, -158, 350., false);
2546
628
        verifyItem(2, 192, 350., false);
2547
629
        QCOMPARE(lvwph->m_minYExtent, 330.);
2548
630
        QCOMPARE(lvwph->m_clipItem->y(), 1228.);
2549
631
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2550
632
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
2551
633
        QCOMPARE(lvwph->contentY(), 1228.);
2552
634
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2553
635
        QTRY_VERIFY(lvwph->isAtYEnd());
2554
636
2555
637
        scrollToTop();
2556
638
2557
639
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2558
640
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2559
641
        verifyItem(0, 0., 150., false);
2560
642
        verifyItem(1, 150., 200., false);
2561
643
        verifyItem(2, 350., 350., false);
2562
644
        verifyItem(3, 700., 350., true);
2563
645
        QCOMPARE(lvwph->m_minYExtent, -20.);
2564
646
        QCOMPARE(lvwph->m_clipItem->y(), 20.);
2565
647
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2566
648
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
2567
649
        QCOMPARE(lvwph->contentY(), 20.);
2568
650
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2569
651
    }
2570
652
2571
653
    void testSetEmptyHeaderWhenPartlyShownNotClipped()
2572
654
    {
2573
655
        changeContentY(30);
2574
656
        lvwph->setHeader(nullptr);
2575
657
2576
658
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2577
659
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2578
660
        verifyItem(0, -30., 150., false);
2579
661
        verifyItem(1, 120., 200., false);
2580
662
        verifyItem(2, 320., 350., false);
2581
663
        verifyItem(3, 670., 350., true);
2582
664
        QCOMPARE(lvwph->m_minYExtent, 0.);
2583
665
        QCOMPARE(lvwph->m_clipItem->y(), 30.);
2584
666
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2585
667
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
2586
668
        QCOMPARE(lvwph->contentY(), 30.);
2587
669
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2588
670
    }
2589
671
2590
672
    void testSetNullDelegate()
2591
673
    {
2592
674
        lvwph->setDelegate(nullptr);
2593
675
2594
676
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);
2595
677
        QCOMPARE(lvwph->m_firstVisibleIndex, -1);
2596
678
        QCOMPARE(lvwph->m_minYExtent, 0.);
2597
679
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2598
680
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2599
681
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2600
682
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2601
683
        QCOMPARE(lvwph->contentY(), 0.);
2602
684
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2603
685
        QTRY_COMPARE(lvwph->contentHeight(), 50.);
2604
686
        QVERIFY(lvwph->isAtYBeginning());
2605
687
        QVERIFY(lvwph->isAtYEnd());
2606
688
    }
2607
689
2608
690
    void testInsertItems()
2609
691
    {
2610
692
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));
2611
693
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));
2612
694
2613
695
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2614
696
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2615
697
        verifyItem(0, 50., 150., false);
2616
698
        verifyItem(1, 200., 125., false);
2617
699
        verifyItem(2, 325., 100., false);
2618
700
        verifyItem(3, 425., 200., false);
2619
701
        verifyItem(4, 625., 350., true);
2620
702
        QCOMPARE(lvwph->m_minYExtent, 0.);
2621
703
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2622
704
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2623
705
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2624
706
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2625
707
        QCOMPARE(lvwph->contentY(), 0.);
2626
708
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2627
709
    }
2628
710
2629
711
    void testInsertItemsOnNotShownPosition()
2630
712
    {
2631
713
        changeContentY(700);
2632
714
2633
715
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2634
716
        QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);
2635
717
        verifyItem(0, -300., 350., false);
2636
718
        verifyItem(1, 50, 350., false);
2637
719
        verifyItem(2, 400, 350., false);
2638
720
        verifyItem(3, 750, 350., true);
2639
721
        QCOMPARE(lvwph->m_minYExtent, 350.);
2640
722
        QCOMPARE(lvwph->m_clipItem->y(), 700.);
2641
723
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2642
724
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2643
725
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2644
726
        QCOMPARE(lvwph->contentY(), 700.);
2645
727
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2646
728
2647
729
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));
2648
730
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));
2649
731
2650
732
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2651
733
        QCOMPARE(lvwph->m_firstVisibleIndex, 4);
2652
734
        verifyItem(0, -300., 350., false);
2653
735
        verifyItem(1, 50, 350., false);
2654
736
        verifyItem(2, 400, 350., false);
2655
737
        verifyItem(3, 750, 350., true);
2656
738
        QCOMPARE(lvwph->m_minYExtent, 1050.);
2657
739
        QCOMPARE(lvwph->m_clipItem->y(), 700.);
2658
740
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2659
741
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2660
742
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2661
743
        QCOMPARE(lvwph->contentY(), 700.);
2662
744
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2663
745
2664
746
        scrollToTop();
2665
747
2666
748
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2667
749
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2668
750
        verifyItem(0, 50., 150., false);
2669
751
        verifyItem(1, 200., 125., false);
2670
752
        verifyItem(2, 325., 100., false);
2671
753
        verifyItem(3, 425., 200., false);
2672
754
        verifyItem(4, 625., 350., true);
2673
755
        QCOMPARE(lvwph->m_minYExtent, 225.);
2674
756
        QCOMPARE(lvwph->m_clipItem->y(), -225.);
2675
757
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2676
758
        QCOMPARE(lvwph->m_headerItem->y(), -225.);
2677
759
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2678
760
        QCOMPARE(lvwph->contentY(), -225.);
2679
761
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2680
762
    }
2681
763
2682
764
    void testInsertItemsAtEndOfViewport()
2683
765
    {
2684
766
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 3), Q_ARG(QVariant, 100));
2685
767
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 3), Q_ARG(QVariant, 125));
2686
768
2687
769
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2688
770
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2689
771
        verifyItem(0, 50., 150., false);
2690
772
        verifyItem(1, 200., 200., false);
2691
773
        verifyItem(2, 400., 350., false);
2692
774
        verifyItem(3, 750., 125., true);
2693
775
        QCOMPARE(lvwph->m_minYExtent, 0.);
2694
776
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2695
777
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2696
778
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2697
779
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2698
780
        QCOMPARE(lvwph->contentY(), 0.);
2699
781
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2700
782
    }
2701
783
2702
784
    void testInsertItemsBeforeValidIndex()
2703
785
    {
2704
786
        changeContentY(520);
2705
787
2706
788
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2707
789
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2708
790
        verifyItem(0, -320., 200., true);
2709
791
        verifyItem(1, -120, 350., false);
2710
792
        verifyItem(2, 230, 350., false);
2711
793
        verifyItem(3, 580, 350., true);
2712
794
        QCOMPARE(lvwph->m_minYExtent, 162.5);
2713
795
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2714
796
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2715
797
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2716
798
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2717
799
        QCOMPARE(lvwph->contentY(), 520.);
2718
800
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2719
801
2720
802
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));
2721
803
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));
2722
804
2723
805
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2724
806
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2725
807
        verifyItem(0, -320., 200., true);
2726
808
        verifyItem(1, -120, 350., false);
2727
809
        verifyItem(2, 230, 350., false);
2728
810
        verifyItem(3, 580, 350., true);
2729
811
        QCOMPARE(lvwph->m_minYExtent, 787.5);
2730
812
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2731
813
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2732
814
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2733
815
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2734
816
        QCOMPARE(lvwph->contentY(), 520.);
2735
817
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2736
818
    }
2737
819
2738
820
    void testInsertItemsBeforeViewport()
2739
821
    {
2740
822
        changeContentY(375);
2741
823
2742
824
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2743
825
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2744
826
        verifyItem(0, -325., 150., true);
2745
827
        verifyItem(1, -175, 200., false);
2746
828
        verifyItem(2, 25, 350., false);
2747
829
        verifyItem(3, 375, 350., false);
2748
830
        verifyItem(4, 725, 350., true);
2749
831
        QCOMPARE(lvwph->m_minYExtent, 0.);
2750
832
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
2751
833
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2752
834
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2753
835
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2754
836
        QCOMPARE(lvwph->contentY(), 375.);
2755
837
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2756
838
2757
839
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100));
2758
840
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125));
2759
841
2760
842
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2761
843
        QCOMPARE(lvwph->m_firstVisibleIndex, 2);
2762
844
        verifyItem(0, -275., 100., true);
2763
845
        verifyItem(1, -175, 200., false);
2764
846
        verifyItem(2, 25, 350., false);
2765
847
        verifyItem(3, 375, 350., false);
2766
848
        verifyItem(4, 725, 350., true);
2767
849
        QCOMPARE(lvwph->m_minYExtent, 490.);
2768
850
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
2769
851
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2770
852
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2771
853
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2772
854
        QCOMPARE(lvwph->contentY(), 375.);
2773
855
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2774
856
2775
857
        scrollToTop();
2776
858
2777
859
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2778
860
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2779
861
        verifyItem(0, 50., 150., false);
2780
862
        verifyItem(1, 200., 125., false);
2781
863
        verifyItem(2, 325., 100., false);
2782
864
        verifyItem(3, 425., 200., false);
2783
865
        verifyItem(4, 625., 350., true);
2784
866
        QCOMPARE(lvwph->m_minYExtent, 225.);
2785
867
        QCOMPARE(lvwph->m_clipItem->y(), -225.);
2786
868
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2787
869
        QCOMPARE(lvwph->m_headerItem->y(), -225.);
2788
870
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2789
871
        QCOMPARE(lvwph->contentY(), -225.);
2790
872
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2791
873
    }
2792
874
2793
875
    void testInsertItemsAtBottom()
2794
876
    {
2795
877
        scrollToBottom();
2796
878
2797
879
        QVERIFY(lvwph->isAtYEnd());
2798
880
2799
881
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 100));
2800
882
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 125));
2801
883
2802
884
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
2803
885
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
2804
886
        verifyItem(0, -508., 350., true);
2805
887
        verifyItem(1, -158, 350., false);
2806
888
        verifyItem(2, 192, 350., false);
2807
889
        verifyItem(3, 542, 125., true);
2808
890
        verifyItem(4, 667, 100., true);
2809
891
        QCOMPARE(lvwph->m_minYExtent, 65.);
2810
892
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2811
893
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2812
894
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2813
895
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2814
896
        QCOMPARE(lvwph->contentY(), 1258.);
2815
897
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2816
898
        QVERIFY(!lvwph->isAtYEnd());
2817
899
2818
900
        scrollToBottom();
2819
901
2820
902
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2821
903
        QCOMPARE(lvwph->m_firstVisibleIndex, 4);
2822
904
        verifyItem(0, -383., 350., true);
2823
905
        verifyItem(1, -33, 350., false);
2824
906
        verifyItem(2, 317, 125., false);
2825
907
        verifyItem(3, 442, 100., false);
2826
908
        QCOMPARE(lvwph->m_minYExtent, -125.);
2827
909
        QCOMPARE(lvwph->m_clipItem->y(), 1483.);
2828
910
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2829
911
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2830
912
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2831
913
        QCOMPARE(lvwph->contentY(), 1483.);
2832
914
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2833
915
        QVERIFY(lvwph->isAtYEnd());
2834
916
    }
2835
917
2836
918
    void testInsertItemAtTop()
2837
919
    {
2838
920
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2839
921
2840
922
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2841
923
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2842
924
        verifyItem(0, 50., 75., false);
2843
925
        verifyItem(1, 125., 150., false);
2844
926
        verifyItem(2, 275., 200., false);
2845
927
        verifyItem(3, 475., 350., false);
2846
928
        QCOMPARE(lvwph->m_minYExtent, 0.);
2847
929
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2848
930
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2849
931
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2850
932
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2851
933
        QCOMPARE(lvwph->contentY(), 0.);
2852
934
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2853
935
        QVERIFY(lvwph->isAtYBeginning());
2854
936
    }
2855
937
2856
938
    void testInsertItem10SmallItemsAtTopWhenAtBottom()
2857
939
    {
2858
940
        scrollToBottom();
2859
941
2860
942
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2861
943
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2862
944
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2863
945
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2864
946
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2865
947
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2866
948
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2867
949
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2868
950
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2869
951
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75));
2870
952
2871
953
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2872
954
        QCOMPARE(lvwph->m_firstVisibleIndex, 13);
2873
955
        verifyItem(0, -508., 350., true);
2874
956
        verifyItem(1, -158, 350., false);
2875
957
        verifyItem(2, 192, 350., false);
2876
958
        QCOMPARE(lvwph->m_minYExtent, 3850.);
2877
959
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2878
960
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2879
961
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2880
962
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2881
963
        QCOMPARE(lvwph->contentY(), 1258.);
2882
964
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2883
965
2884
966
        changeContentY(-1700);
2885
967
2886
968
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 12);
2887
969
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2888
970
        verifyItem(0, -308., 75., true);
2889
971
        verifyItem(1, -233., 75., true);
2890
972
        verifyItem(2, -158., 75., true);
2891
973
        verifyItem(3, -83., 75., true);
2892
974
        verifyItem(4, -8., 75., false);
2893
975
        verifyItem(5, 67., 75., false);
2894
976
        verifyItem(6, 142., 75., false);
2895
977
        verifyItem(7, 217., 75., false);
2896
978
        verifyItem(8, 292., 75., false);
2897
979
        verifyItem(9, 367., 75., false);
2898
980
        verifyItem(10, 442., 150., false);
2899
981
        verifyItem(11, 592., 200., true);
2900
982
        QCOMPARE(lvwph->m_minYExtent, 750.);
2901
983
        QCOMPARE(lvwph->m_clipItem->y(), -392.);
2902
984
        QCOMPARE(lvwph->m_clipItem->clip(), true);
2903
985
        QCOMPARE(lvwph->m_headerItem->y(), -442.);
2904
986
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2905
987
        QCOMPARE(lvwph->contentY(), -442.);
2906
988
        QCOMPARE(lvwph->m_headerItemShownHeight, 50.);
2907
989
    }
2908
990
2909
991
    void testRemoveItemsAtTop()
2910
992
    {
2911
993
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));
2912
994
2913
995
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2914
996
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2915
997
        verifyItem(0, 50., 350., false);
2916
998
        verifyItem(1, 400., 350., false);
2917
999
        verifyItem(2, 750., 350., true);
2918
1000
        QCOMPARE(lvwph->m_minYExtent, 0.);
2919
1001
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
2920
1002
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2921
1003
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2922
1004
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2923
1005
        QCOMPARE(lvwph->contentY(), 0.);
2924
1006
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2925
1007
        QVERIFY(lvwph->isAtYBeginning());
2926
1008
    }
2927
1009
2928
1010
    void testRemoveNonCreatedItemsAtTopWhenAtBottom()
2929
1011
    {
2930
1012
        scrollToBottom();
2931
1013
2932
1014
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));
2933
1015
2934
1016
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2935
1017
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2936
1018
        verifyItem(0, -508., 350., true);
2937
1019
        verifyItem(1, -158, 350., false);
2938
1020
        verifyItem(2, 192, 350., false);
2939
1021
        QCOMPARE(lvwph->m_minYExtent, -350.);
2940
1022
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
2941
1023
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2942
1024
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2943
1025
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2944
1026
        QCOMPARE(lvwph->contentY(), 1258.);
2945
1027
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2946
1028
    }
2947
1029
2948
1030
    void testRemoveLastItemsAtBottom()
2949
1031
    {
2950
1032
        scrollToBottom();
2951
1033
2952
1034
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));
2953
1035
2954
1036
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
2955
1037
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2956
1038
        verifyItem(0, -358., 200., true);
2957
1039
        verifyItem(1, -158, 350., false);
2958
1040
        verifyItem(2, 192, 350., false);
2959
1041
        QCOMPARE(lvwph->m_minYExtent, 150.);
2960
1042
        QCOMPARE(lvwph->m_clipItem->y(), 558.);
2961
1043
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2962
1044
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2963
1045
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2964
1046
        QCOMPARE(lvwph->contentY(), 558.);
2965
1047
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2966
1048
    }
2967
1049
2968
1050
    void testRemoveItemOutOfViewport()
2969
1051
    {
2970
1052
        changeContentY(520);
2971
1053
2972
1054
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2973
1055
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
2974
1056
        verifyItem(0, -320., 200., true);
2975
1057
        verifyItem(1, -120, 350., false);
2976
1058
        verifyItem(2, 230, 350., false);
2977
1059
        verifyItem(3, 580, 350., true);
2978
1060
        QCOMPARE(lvwph->m_minYExtent, 162.5);
2979
1061
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2980
1062
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2981
1063
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2982
1064
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
2983
1065
        QCOMPARE(lvwph->contentY(), 520.);
2984
1066
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
2985
1067
2986
1068
2987
1069
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));
2988
1070
2989
1071
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
2990
1072
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
2991
1073
        verifyItem(0, -270., 150., true);
2992
1074
        verifyItem(1, -120., 350., false);
2993
1075
        verifyItem(2, 230, 350., false);
2994
1076
        verifyItem(3, 580, 350., true);
2995
1077
        QCOMPARE(lvwph->m_minYExtent, -200.);
2996
1078
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
2997
1079
        QCOMPARE(lvwph->m_clipItem->clip(), false);
2998
1080
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
2999
1081
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3000
1082
        QCOMPARE(lvwph->contentY(), 520.);
3001
1083
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3002
1084
    }
3003
1085
3004
1086
    void testMoveFirstItems()
3005
1087
    {
3006
1088
        QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));
3007
1089
3008
1090
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3009
1091
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3010
1092
        verifyItem(0, 50., 200., false);
3011
1093
        verifyItem(1, 250., 150., false);
3012
1094
        verifyItem(2, 400., 350., false);
3013
1095
        verifyItem(3, 750., 350., true);
3014
1096
        QCOMPARE(lvwph->m_minYExtent, 0.);
3015
1097
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3016
1098
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3017
1099
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3018
1100
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3019
1101
        QCOMPARE(lvwph->contentY(), 0.);
3020
1102
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3021
1103
3022
1104
    }
3023
1105
3024
1106
    void testMoveFirstOutOfVisibleItems()
3025
1107
    {
3026
1108
        QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));
3027
1109
3028
1110
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3029
1111
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3030
1112
        verifyItem(0, 50., 200., false);
3031
1113
        verifyItem(1, 250., 350., false);
3032
1114
        verifyItem(2, 600., 350., true);
3033
1115
        QCOMPARE(lvwph->m_minYExtent, 0.);
3034
1116
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3035
1117
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3036
1118
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3037
1119
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3038
1120
        QCOMPARE(lvwph->contentY(), 0.);
3039
1121
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3040
1122
3041
1123
    }
3042
1124
3043
1125
    void testMoveFirstToLastAtBottom()
3044
1126
    {
3045
1127
        scrollToBottom();
3046
1128
3047
1129
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3048
1130
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3049
1131
        verifyItem(0, -508., 350., true);
3050
1132
        verifyItem(1, -158, 350., false);
3051
1133
        verifyItem(2, 192, 350., false);
3052
1134
        QCOMPARE(lvwph->m_minYExtent, 350.);
3053
1135
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
3054
1136
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3055
1137
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3056
1138
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3057
1139
        QCOMPARE(lvwph->contentY(), 1258.);
3058
1140
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3059
1141
3060
1142
        QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));
3061
1143
3062
1144
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3063
1145
        QCOMPARE(lvwph->m_firstVisibleIndex, 2);
3064
1146
        verifyItem(0, -508., 350., true);
3065
1147
        verifyItem(1, -158, 350., false);
3066
1148
        verifyItem(2, 192, 350., false);
3067
1149
        verifyItem(3, 542, 150., true);
3068
1150
        QCOMPARE(lvwph->m_minYExtent, -100.);
3069
1151
        QCOMPARE(lvwph->m_clipItem->y(), 1258.);
3070
1152
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3071
1153
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3072
1154
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3073
1155
        QCOMPARE(lvwph->contentY(), 1258.);
3074
1156
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3075
1157
        QVERIFY(!lvwph->isAtYEnd());
3076
1158
    }
3077
1159
3078
1160
    void testChangeSizeVisibleItemNotOnViewport()
3079
1161
    {
3080
1162
        changeContentY(440);
3081
1163
3082
1164
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
3083
1165
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3084
1166
        verifyItem(0, -390., 150., true);
3085
1167
        verifyItem(1, -240., 200., true);
3086
1168
        verifyItem(2, -40, 350., false);
3087
1169
        verifyItem(3, 310, 350., false);
3088
1170
        verifyItem(4, 660, 350., true);
3089
1171
        QCOMPARE(lvwph->m_minYExtent, 0.);
3090
1172
        QCOMPARE(lvwph->m_clipItem->y(), 440.);
3091
1173
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3092
1174
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3093
1175
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3094
1176
        QCOMPARE(lvwph->contentY(), 440.);
3095
1177
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3096
1178
3097
1179
        model->setProperty(1, "size", 100);
3098
1180
3099
1181
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
3100
1182
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3101
1183
        verifyItem(0, -290., 150., true);
3102
1184
        verifyItem(1, -140., 100., true);
3103
1185
        verifyItem(2, -40, 350., false);
3104
1186
        verifyItem(3, 310, 350., false);
3105
1187
        verifyItem(4, 660, 350., true);
3106
1188
        QCOMPARE(lvwph->m_minYExtent, -100.);
3107
1189
        QCOMPARE(lvwph->m_clipItem->y(), 440.);
3108
1190
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3109
1191
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3110
1192
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3111
1193
        QCOMPARE(lvwph->contentY(), 440.);
3112
1194
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3113
1195
    }
3114
1196
3115
1197
    void testShowHeaderCloseToTheTop()
3116
1198
    {
3117
1199
        changeContentY(375);
3118
1200
3119
1201
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
3120
1202
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3121
1203
        verifyItem(0, -325., 150., true);
3122
1204
        verifyItem(1, -175, 200., false);
3123
1205
        verifyItem(2, 25, 350., false);
3124
1206
        verifyItem(3, 375, 350., false);
3125
1207
        verifyItem(4, 725, 350., true);
3126
1208
        QCOMPARE(lvwph->m_minYExtent, 0.);
3127
1209
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
3128
1210
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3129
1211
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3130
1212
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3131
1213
        QCOMPARE(lvwph->contentY(), 375.);
3132
1214
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;
3133
1215
3134
1216
        lvwph->showHeader();
3135
1217
3136
1218
        QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());
3137
1219
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
3138
1220
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3139
1221
        verifyItem(0, -375., 150., true);
3140
1222
        verifyItem(1, -225, 200., true);
3141
1223
        verifyItem(2, -25, 350., false);
3142
1224
        verifyItem(3, 325, 350., false);
3143
1225
        verifyItem(4, 675, 350., true);
3144
1226
        QCOMPARE(lvwph->m_minYExtent, 50.);
3145
1227
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
3146
1228
        QCOMPARE(lvwph->m_clipItem->clip(), true);
3147
1229
        QCOMPARE(lvwph->m_headerItem->y(), 325.);
3148
1230
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3149
1231
        QCOMPARE(lvwph->contentY(), 325.);
3150
1232
        QCOMPARE(lvwph->m_headerItemShownHeight, 50.);;
3151
1233
3152
1234
        scrollToTop();
3153
1235
3154
1236
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3155
1237
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3156
1238
        verifyItem(0, 50., 150., false);
3157
1239
        verifyItem(1, 200., 200., false);
3158
1240
        verifyItem(2, 400., 350., false);
3159
1241
        verifyItem(3, 750., 350., true);
3160
1242
        QCOMPARE(lvwph->m_minYExtent, 50.);
3161
1243
        QCOMPARE(lvwph->m_clipItem->y(), -50.);
3162
1244
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3163
1245
        QCOMPARE(lvwph->m_headerItem->y(), -50.);
3164
1246
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3165
1247
        QCOMPARE(lvwph->contentY(), -50.);
3166
1248
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3167
1249
    }
3168
1250
3169
1251
    void testShowHeaderAtBottom()
3170
1252
    {
3171
1253
        scrollToBottom();
3172
1254
3173
1255
        lvwph->showHeader();
3174
1256
3175
1257
        QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());
3176
1258
        QTRY_VERIFY (lvwph->isAtYEnd());
3177
1259
    }
3178
1260
3179
1261
    void growWindow()
3180
1262
    {
3181
1263
        view->rootObject()->setHeight(850);
3182
1264
3183
1265
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
3184
1266
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3185
1267
        verifyItem(0, 50., 150., false);
3186
1268
        verifyItem(1, 200., 200., false);
3187
1269
        verifyItem(2, 400., 350., false);
3188
1270
        verifyItem(3, 750., 350., false);
3189
1271
        verifyItem(4, 1100., 350., true);
3190
1272
        QCOMPARE(lvwph->m_minYExtent, 0.);
3191
1273
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3192
1274
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3193
1275
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3194
1276
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3195
1277
        QCOMPARE(lvwph->contentY(), 0.);
3196
1278
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3197
1279
    }
3198
1280
3199
1281
    void growWindowAtBottom()
3200
1282
    {
3201
1283
        scrollToBottom();
3202
1284
3203
1285
        view->rootObject()->setHeight(850);
3204
1286
3205
1287
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3206
1288
        QCOMPARE(lvwph->m_firstVisibleIndex, 2);
3207
1289
        verifyItem(0, -550., 350., true);
3208
1290
        verifyItem(1, -200., 350., false);
3209
1291
        verifyItem(2, 150, 350., false);
3210
1292
        verifyItem(3, 500, 350., false);
3211
1293
        QCOMPARE(lvwph->m_minYExtent, 350.);
3212
1294
        QCOMPARE(lvwph->m_clipItem->y(), 950.);
3213
1295
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3214
1296
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3215
1297
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3216
1298
        QCOMPARE(lvwph->contentY(), 950.);
3217
1299
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3218
1300
    }
3219
1301
3220
1302
private:
3221
1303
    QQuickView *view;
3222
1304
    ListViewWithPageHeader *lvwph;
3223
1305
    QQuickListModel *model;
3224
1306
    QQmlComponent *otherDelegate;
3225
1307
};
3226
1308
3227
1309
QTEST_MAIN(ListViewWithPageHeaderTest)
3228
1310
3229
1311
#include "listviewwithpageheadertest.moc"
3230
0
1312
3231
=== added file 'tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp'
3232
--- tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp	1970-01-01 00:00:00 +0000
3233
+++ tests/plugins/ListViewWithPageHeader/listviewwithpageheadertestsection.cpp	2013-07-01 11:23:32 +0000
3234
@@ -0,0 +1,1567 @@
3235
1
/*
3236
2
 * Copyright (C) 2013 Canonical, Ltd.
3237
3
 *
3238
4
 * This program is free software; you can redistribute it and/or modify
3239
5
 * it under the terms of the GNU General Public License as published by
3240
6
 * the Free Software Foundation; version 3.
3241
7
 *
3242
8
 * This program is distributed in the hope that it will be useful,
3243
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3244
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3245
11
 * GNU General Public License for more details.
3246
12
 *
3247
13
 * You should have received a copy of the GNU General Public License
3248
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3249
15
 */
3250
16
3251
17
#include "listviewwithpageheader.h"
3252
18
3253
19
#include <QAbstractItemModel>
3254
20
#include <QQmlEngine>
3255
21
#include <QQuickView>
3256
22
#include <QtTestGui>
3257
23
#include <private/qquicklistmodel_p.h>
3258
24
#include <private/qquickanimation_p.h>
3259
25
#include <private/qquickitem_p.h>
3260
26
3261
27
class ListViewWithPageHeaderTestSection : public QObject
3262
28
{
3263
29
    Q_OBJECT
3264
30
3265
31
private:
3266
32
    void verifyItem(int visibleIndex, qreal pos, qreal height, bool culled, const QString &sectionHeader, bool sectionHeaderCulled)
3267
33
    {
3268
34
        QTRY_VERIFY(visibleIndex < lvwph->m_visibleItems.count());
3269
35
        QTRY_COMPARE(lvwph->m_visibleItems[visibleIndex]->y(), pos);
3270
36
        QTRY_COMPARE(lvwph->m_visibleItems[visibleIndex]->height(), height);
3271
37
        QCOMPARE(QQuickItemPrivate::get(lvwph->m_visibleItems[visibleIndex]->m_item)->culled, culled);
3272
38
        QCOMPARE(section(lvwph->m_visibleItems[visibleIndex]->m_sectionItem), sectionHeader);
3273
39
        if (!sectionHeader.isNull()) {
3274
40
            QCOMPARE(QQuickItemPrivate::get(lvwph->m_visibleItems[visibleIndex]->m_sectionItem)->culled, sectionHeaderCulled);
3275
41
        }
3276
42
    }
3277
43
3278
44
    void changeContentY(qreal change)
3279
45
    {
3280
46
        const qreal dest = lvwph->contentY() + change;
3281
47
        if (dest > lvwph->contentY()) {
3282
48
            const qreal jump = 25;
3283
49
            while (lvwph->contentY() + jump < dest) {
3284
50
                lvwph->setContentY(lvwph->contentY() + jump);
3285
51
                QTest::qWait(1);
3286
52
            }
3287
53
        } else {
3288
54
            const qreal jump = -25;
3289
55
            while (lvwph->contentY() + jump > dest) {
3290
56
                lvwph->setContentY(lvwph->contentY() + jump);
3291
57
                QTest::qWait(1);
3292
58
            }
3293
59
        }
3294
60
        lvwph->setContentY(dest);
3295
61
        QTest::qWait(1);
3296
62
    }
3297
63
3298
64
    void scrollToTop()
3299
65
    {
3300
66
        const qreal jump = -25;
3301
67
        while (!lvwph->isAtYBeginning()) {
3302
68
            if (lvwph->contentY() + jump > -lvwph->minYExtent()) {
3303
69
                lvwph->setContentY(lvwph->contentY() + jump);
3304
70
            } else {
3305
71
                lvwph->setContentY(lvwph->contentY() - 1);
3306
72
            }
3307
73
            QTest::qWait(1);
3308
74
        }
3309
75
    }
3310
76
3311
77
    void scrollToBottom()
3312
78
    {
3313
79
        const qreal jump = 25;
3314
80
        while (!lvwph->isAtYEnd()) {
3315
81
            if (lvwph->contentY() + lvwph->height() + jump < lvwph->contentHeight()) {
3316
82
                lvwph->setContentY(lvwph->contentY() + jump);
3317
83
            } else {
3318
84
                lvwph->setContentY(lvwph->contentY() + 1);
3319
85
            }
3320
86
            QTest::qWait(1);
3321
87
        }
3322
88
    }
3323
89
3324
90
    void verifyInitialTopPosition()
3325
91
    {
3326
92
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3327
93
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3328
94
        verifyItem(0, 50., 190., false, "Agressive", false);
3329
95
        verifyItem(1, 240., 240., false, "Regular", false);
3330
96
        verifyItem(2, 480., 390., false, "Mild", false);
3331
97
        QCOMPARE(lvwph->m_minYExtent, 0.);
3332
98
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3333
99
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3334
100
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3335
101
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3336
102
        QCOMPARE(lvwph->contentY(), 0.);
3337
103
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3338
104
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3339
105
    }
3340
106
3341
107
    QString section(QQuickItem *item)
3342
108
    {
3343
109
        return item ? QQmlEngine::contextForObject(item)->parentContext()->contextProperty(QLatin1String("section")).toString() : QString();
3344
110
    }
3345
111
3346
112
private Q_SLOTS:
3347
113
3348
114
    void initTestCase()
3349
115
    {
3350
116
    }
3351
117
3352
118
    void init()
3353
119
    {
3354
120
        view = new QQuickView();
3355
121
        view->engine()->addImportPath(BUILT_PLUGINS_DIR);
3356
122
        view->setSource(QUrl::fromLocalFile(LISTVIEWWITHPAGEHEADER_FOLDER "/test_section.qml"));
3357
123
        lvwph = dynamic_cast<ListViewWithPageHeader*>(view->rootObject()->findChild<QQuickFlickable*>());
3358
124
        model = view->rootObject()->findChild<QQuickListModel*>();
3359
125
        otherDelegate = view->rootObject()->findChild<QQmlComponent*>();
3360
126
        QVERIFY(lvwph);
3361
127
        QVERIFY(model);
3362
128
        QVERIFY(otherDelegate);
3363
129
        view->show();
3364
130
        QTest::qWaitForWindowExposed(view);
3365
131
3366
132
        verifyInitialTopPosition();
3367
133
    }
3368
134
3369
135
    void cleanup()
3370
136
    {
3371
137
        delete view;
3372
138
    }
3373
139
3374
140
    void testCreationDeletion()
3375
141
    {
3376
142
        // Nothing, init/cleanup already tests this
3377
143
    }
3378
144
3379
145
    void testDrag1PixelUp()
3380
146
    {
3381
147
        lvwph->setContentY(lvwph->contentY() + 1);
3382
148
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3383
149
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3384
150
        verifyItem(0, 49., 190., false, "Agressive", false);
3385
151
        verifyItem(1, 239., 240., false, "Regular", false);
3386
152
        verifyItem(2, 479., 390., false, "Mild", false);
3387
153
        QCOMPARE(lvwph->m_minYExtent, 0.);
3388
154
        QCOMPARE(lvwph->m_clipItem->y(), 1.);
3389
155
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3390
156
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3391
157
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3392
158
        QCOMPARE(lvwph->contentY(), 1.);
3393
159
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3394
160
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3395
161
    }
3396
162
3397
163
    void testHeaderDetachDragDown()
3398
164
    {
3399
165
        QTest::mousePress(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 0));
3400
166
        QTest::qWait(100);
3401
167
        QTest::mouseMove(view, QPoint(0, 5));
3402
168
        QTest::qWait(100);
3403
169
        QTest::mouseMove(view, QPoint(0, 10));
3404
170
        QTest::qWait(100);
3405
171
        QTest::mouseMove(view, QPoint(0, 15));
3406
172
        QTest::qWait(100);
3407
173
        QTest::mouseMove(view, QPoint(0, 20));
3408
174
        QTest::qWait(100);
3409
175
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3410
176
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3411
177
        verifyItem(0, 55., 190., false, "Agressive", false);
3412
178
        verifyItem(1, 245., 240., false, "Regular", false);
3413
179
        verifyItem(2, 485., 390., false, "Mild", false);
3414
180
        QCOMPARE(lvwph->m_minYExtent, 0.);
3415
181
        QCOMPARE(lvwph->m_clipItem->y(), -5.);
3416
182
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3417
183
        QCOMPARE(lvwph->m_headerItem->y(), -5.);
3418
184
        QCOMPARE(lvwph->m_headerItem->height(), 55.);
3419
185
        QCOMPARE(lvwph->contentY(), -5.);
3420
186
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3421
187
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3422
188
3423
189
        QTest::mouseRelease(view, Qt::LeftButton, Qt::NoModifier, QPoint(0, 15));
3424
190
3425
191
        verifyInitialTopPosition();
3426
192
    }
3427
193
3428
194
    void testDrag375PixelUp()
3429
195
    {
3430
196
        changeContentY(375);
3431
197
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3432
198
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3433
199
        verifyItem(0, -325., 190., true, "Agressive", true);
3434
200
        verifyItem(1, -135, 240., false, "Regular", true);
3435
201
        verifyItem(2, 105, 390., false, "Mild", false);
3436
202
        verifyItem(3, 495, 390., false, "Bold", false);
3437
203
        QCOMPARE(lvwph->m_minYExtent, 0.);
3438
204
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
3439
205
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3440
206
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3441
207
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3442
208
        QCOMPARE(lvwph->contentY(), 375.);
3443
209
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3444
210
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3445
211
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
3446
212
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3447
213
    }
3448
214
3449
215
    void testDrag520PixelUp()
3450
216
    {
3451
217
        changeContentY(520);
3452
218
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3453
219
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
3454
220
        verifyItem(0, -280., 240., true, "Regular", true);
3455
221
        verifyItem(1, -40, 390., false, "Mild", true);
3456
222
        verifyItem(2, 350, 390., false, "Bold", false);
3457
223
        verifyItem(3, 740, 350., true, QString(), true);
3458
224
        QCOMPARE(lvwph->m_minYExtent, 152.5);
3459
225
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
3460
226
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3461
227
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3462
228
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3463
229
        QCOMPARE(lvwph->contentY(), 520.);
3464
230
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3465
231
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3466
232
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
3467
233
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3468
234
    }
3469
235
3470
236
    void testDragHeaderUpThenShow()
3471
237
    {
3472
238
        changeContentY(120);
3473
239
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3474
240
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3475
241
        verifyItem(0, -70., 190., false, "Agressive", true);
3476
242
        verifyItem(1, 120., 240., false, "Regular", false);
3477
243
        verifyItem(2, 360., 390., false, "Mild", false);
3478
244
        verifyItem(3, 750., 390., true, "Bold", true);
3479
245
        QCOMPARE(lvwph->m_minYExtent, 0.);
3480
246
        QCOMPARE(lvwph->m_clipItem->y(), 120.);
3481
247
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3482
248
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3483
249
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3484
250
        QCOMPARE(lvwph->contentY(), 120.);
3485
251
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3486
252
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3487
253
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));
3488
254
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3489
255
3490
256
        changeContentY(-30);
3491
257
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3492
258
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3493
259
        verifyItem(0, -70., 190., false, "Agressive", true);
3494
260
        verifyItem(1, 120., 240., false, "Regular", false);
3495
261
        verifyItem(2, 360., 390., false, "Mild", false);
3496
262
        verifyItem(3, 750., 390., true, "Bold", true);
3497
263
        QCOMPARE(lvwph->m_minYExtent, 0.);
3498
264
        QCOMPARE(lvwph->m_clipItem->y(), 120.);
3499
265
        QCOMPARE(lvwph->m_clipItem->clip(), true);
3500
266
        QTRY_COMPARE(lvwph->m_headerItem->y(), 70.);
3501
267
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3502
268
        QCOMPARE(lvwph->contentY(), 90.);
3503
269
        QCOMPARE(lvwph->m_headerItemShownHeight, 30.);
3504
270
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3505
271
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));
3506
272
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3507
273
    }
3508
274
3509
275
    void testDragHeaderUpThenShowWithoutHidingTotally()
3510
276
    {
3511
277
        changeContentY(10);
3512
278
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3513
279
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3514
280
        verifyItem(0, 40., 190., false, "Agressive", false);
3515
281
        verifyItem(1, 230., 240., false, "Regular", false);
3516
282
        verifyItem(2, 470., 390., false, "Mild", false);
3517
283
        QCOMPARE(lvwph->m_minYExtent, 0.);
3518
284
        QCOMPARE(lvwph->m_clipItem->y(), 10.);
3519
285
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3520
286
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3521
287
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3522
288
        QCOMPARE(lvwph->contentY(), 10.);
3523
289
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3524
290
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3525
291
3526
292
        changeContentY(-1);
3527
293
3528
294
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3529
295
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3530
296
        verifyItem(0, 41., 190., false, "Agressive", false);
3531
297
        verifyItem(1, 231., 240., false, "Regular", false);
3532
298
        verifyItem(2, 471., 390., false, "Mild", false);
3533
299
        QCOMPARE(lvwph->m_minYExtent, 0.);
3534
300
        QCOMPARE(lvwph->m_clipItem->y(), 9.);
3535
301
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3536
302
        QTRY_COMPARE(lvwph->m_headerItem->y(), 0.);
3537
303
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3538
304
        QCOMPARE(lvwph->contentY(), 9.);
3539
305
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3540
306
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3541
307
    }
3542
308
3543
309
    void testPositionAtBeginningIndex0Visible()
3544
310
    {
3545
311
        changeContentY(375);
3546
312
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3547
313
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3548
314
        verifyItem(0, -325., 190., true, "Agressive", true);
3549
315
        verifyItem(1, -135, 240., false, "Regular", true);
3550
316
        verifyItem(2, 105, 390., false, "Mild", false);
3551
317
        verifyItem(3, 495, 390., false, "Bold", false);
3552
318
        QCOMPARE(lvwph->m_minYExtent, 0.);
3553
319
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
3554
320
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3555
321
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3556
322
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3557
323
        QCOMPARE(lvwph->contentY(), 375.);
3558
324
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3559
325
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3560
326
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
3561
327
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3562
328
3563
329
        lvwph->positionAtBeginning();
3564
330
3565
331
        verifyInitialTopPosition();
3566
332
    }
3567
333
3568
334
    void testPositionAtBeginningIndex0NotVisible()
3569
335
    {
3570
336
        changeContentY(520);
3571
337
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3572
338
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
3573
339
        verifyItem(0, -280., 240., true, "Regular", true);
3574
340
        verifyItem(1, -40, 390., false, "Mild", true);
3575
341
        verifyItem(2, 350, 390., false, "Bold", false);
3576
342
        verifyItem(3, 740, 350., true, QString(), true);
3577
343
        QCOMPARE(lvwph->m_minYExtent, 152.5);
3578
344
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
3579
345
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3580
346
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3581
347
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3582
348
        QCOMPARE(lvwph->contentY(), 520.);
3583
349
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3584
350
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3585
351
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
3586
352
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3587
353
3588
354
        lvwph->positionAtBeginning();
3589
355
3590
356
        verifyInitialTopPosition();
3591
357
    }
3592
358
3593
359
    void testIndex0GrowOnScreen()
3594
360
    {
3595
361
        model->setProperty(0, "size", 400);
3596
362
3597
363
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3598
364
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3599
365
        verifyItem(0, 50., 440., false, "Agressive", false);
3600
366
        verifyItem(1, 490., 240., false, "Regular", false);
3601
367
        verifyItem(2, 730., 390., true, "Mild", true);
3602
368
        QCOMPARE(lvwph->m_minYExtent, 0.);
3603
369
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3604
370
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3605
371
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3606
372
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3607
373
        QCOMPARE(lvwph->contentY(), 0.);
3608
374
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3609
375
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3610
376
    }
3611
377
3612
378
    void testIndex0GrowOffScreen()
3613
379
    {
3614
380
        changeContentY(375);
3615
381
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3616
382
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3617
383
        verifyItem(0, -325., 190., true, "Agressive", true);
3618
384
        verifyItem(1, -135, 240., false, "Regular", true);
3619
385
        verifyItem(2, 105, 390., false, "Mild", false);
3620
386
        verifyItem(3, 495, 390., false, "Bold", false);
3621
387
        QCOMPARE(lvwph->m_minYExtent, 0.);
3622
388
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
3623
389
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3624
390
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3625
391
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3626
392
        QCOMPARE(lvwph->contentY(), 375.);
3627
393
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3628
394
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3629
395
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
3630
396
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3631
397
3632
398
        model->setProperty(0, "size", 400);
3633
399
3634
400
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3635
401
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3636
402
        verifyItem(0, -575., 440., true, "Agressive", true);
3637
403
        verifyItem(1, -135, 240., false, "Regular", true);
3638
404
        verifyItem(2, 105, 390., false, "Mild", false);
3639
405
        verifyItem(3, 495, 390., false, "Bold", false);
3640
406
        QCOMPARE(lvwph->m_minYExtent, 250.);
3641
407
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
3642
408
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3643
409
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3644
410
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3645
411
        QCOMPARE(lvwph->contentY(), 375.);
3646
412
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3647
413
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3648
414
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
3649
415
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3650
416
3651
417
        scrollToTop();
3652
418
3653
419
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3654
420
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3655
421
        verifyItem(0, 50., 440., false, "Agressive", false);
3656
422
        verifyItem(1, 490, 240., false, "Regular", false);
3657
423
        verifyItem(2, 730, 390., true, "Mild", true);
3658
424
        QCOMPARE(lvwph->m_minYExtent, 250.);
3659
425
        QCOMPARE(lvwph->m_clipItem->y(), -250.);
3660
426
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3661
427
        QCOMPARE(lvwph->m_headerItem->y(), -250.);
3662
428
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3663
429
        QCOMPARE(lvwph->contentY(), -250.);
3664
430
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3665
431
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3666
432
3667
433
        changeContentY(30);
3668
434
3669
435
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3670
436
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3671
437
        verifyItem(0, 20., 440., false, "Agressive", false);
3672
438
        verifyItem(1, 460, 240., false, "Regular", false);
3673
439
        verifyItem(2, 700, 390., true, "Mild", true);
3674
440
        QCOMPARE(lvwph->m_minYExtent, 250.);
3675
441
        QCOMPARE(lvwph->m_clipItem->y(), -220.);
3676
442
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3677
443
        QCOMPARE(lvwph->m_headerItem->y(), -250.);
3678
444
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3679
445
        QCOMPARE(lvwph->contentY(), -220.);
3680
446
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3681
447
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3682
448
    }
3683
449
3684
450
    void testIndex0GrowNotCreated()
3685
451
    {
3686
452
        changeContentY(520);
3687
453
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3688
454
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
3689
455
        verifyItem(0, -280., 240., true, "Regular", true);
3690
456
        verifyItem(1, -40, 390., false, "Mild", true);
3691
457
        verifyItem(2, 350, 390., false, "Bold", false);
3692
458
        verifyItem(3, 740, 350., true, QString(), true);
3693
459
        QCOMPARE(lvwph->m_minYExtent, 152.5);
3694
460
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
3695
461
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3696
462
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3697
463
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3698
464
        QCOMPARE(lvwph->contentY(), 520.);
3699
465
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3700
466
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3701
467
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
3702
468
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3703
469
3704
470
        model->setProperty(0, "size", 400);
3705
471
3706
472
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
3707
473
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
3708
474
        verifyItem(0, -280., 240., true, "Regular", true);
3709
475
        verifyItem(1, -40, 390., false, "Mild", true);
3710
476
        verifyItem(2, 350, 390., false, "Bold", false);
3711
477
        verifyItem(3, 740, 350., true, QString(), true);
3712
478
        QCOMPARE(lvwph->m_minYExtent, 152.5);
3713
479
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
3714
480
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3715
481
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3716
482
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3717
483
        QCOMPARE(lvwph->contentY(), 520.);
3718
484
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3719
485
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3720
486
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
3721
487
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3722
488
3723
489
        scrollToTop();
3724
490
3725
491
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3726
492
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3727
493
        verifyItem(0, 50., 440., false, "Agressive", false);
3728
494
        verifyItem(1, 490, 240., false, "Regular", false);
3729
495
        verifyItem(2, 730, 390., true, "Mild", true);
3730
496
        QCOMPARE(lvwph->m_minYExtent, 250.);
3731
497
        QCOMPARE(lvwph->m_clipItem->y(), -250.);
3732
498
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3733
499
        QCOMPARE(lvwph->m_headerItem->y(), -250.);
3734
500
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3735
501
        QCOMPARE(lvwph->contentY(), -250.);
3736
502
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3737
503
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3738
504
    }
3739
505
3740
506
    void testShowHideShowHeaderAtBottom()
3741
507
    {
3742
508
        scrollToBottom();
3743
509
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3744
510
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3745
511
        verifyItem(0, -588., 390., true, "Bold", true);
3746
512
        verifyItem(1, -198, 350., false, QString(), true);
3747
513
        verifyItem(2, 152, 390., false, "Lazy", false);
3748
514
        QCOMPARE(lvwph->m_minYExtent, 310.);
3749
515
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
3750
516
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3751
517
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3752
518
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3753
519
        QCOMPARE(lvwph->contentY(), 1458.);
3754
520
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3755
521
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3756
522
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3757
523
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3758
524
3759
525
        changeContentY(-30);
3760
526
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3761
527
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3762
528
        verifyItem(0, -588., 390., true, "Bold", true);
3763
529
        verifyItem(1, -198, 350., false, QString(), true);
3764
530
        verifyItem(2, 152, 390., false, "Lazy", false);
3765
531
        QCOMPARE(lvwph->m_minYExtent, 310.);
3766
532
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
3767
533
        QCOMPARE(lvwph->m_clipItem->clip(), true);
3768
534
        QCOMPARE(lvwph->m_headerItem->y(), 1408.);
3769
535
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3770
536
        QCOMPARE(lvwph->contentY(), 1428.);
3771
537
        QCOMPARE(lvwph->m_headerItemShownHeight, 30.);
3772
538
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3773
539
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3774
540
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3775
541
3776
542
        changeContentY(30);
3777
543
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3778
544
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3779
545
        verifyItem(0, -588., 390., true, "Bold", true);
3780
546
        verifyItem(1, -198, 350., false, QString(), true);
3781
547
        verifyItem(2, 152, 390., false, "Lazy", false);
3782
548
        QCOMPARE(lvwph->m_minYExtent, 310.);
3783
549
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
3784
550
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3785
551
        QCOMPARE(lvwph->m_headerItem->y(), -310.);
3786
552
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3787
553
        QCOMPARE(lvwph->contentY(), 1458.);
3788
554
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3789
555
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3790
556
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3791
557
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3792
558
3793
559
        changeContentY(-30);
3794
560
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3795
561
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3796
562
        verifyItem(0, -588., 390., true, "Bold", true);
3797
563
        verifyItem(1, -198, 350., false, QString(), true);
3798
564
        verifyItem(2, 152, 390., false, "Lazy", false);
3799
565
        QCOMPARE(lvwph->m_minYExtent, 310.);
3800
566
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
3801
567
        QCOMPARE(lvwph->m_clipItem->clip(), true);
3802
568
        QCOMPARE(lvwph->m_headerItem->y(), 1408.);
3803
569
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3804
570
        QCOMPARE(lvwph->contentY(), 1428.);
3805
571
        QCOMPARE(lvwph->m_headerItemShownHeight, 30.);
3806
572
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3807
573
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3808
574
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3809
575
    }
3810
576
3811
577
    void testChangeDelegateAtBottom()
3812
578
    {
3813
579
        scrollToBottom();
3814
580
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3815
581
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3816
582
        verifyItem(0, -588., 390., true, "Bold", true);
3817
583
        verifyItem(1, -198, 350., false, QString(), true);
3818
584
        verifyItem(2, 152, 390., false, "Lazy", false);
3819
585
        QCOMPARE(lvwph->m_minYExtent, 310.);
3820
586
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
3821
587
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3822
588
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3823
589
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3824
590
        QCOMPARE(lvwph->contentY(), 1458.);
3825
591
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3826
592
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3827
593
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3828
594
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3829
595
3830
596
        lvwph->setDelegate(otherDelegate);
3831
597
3832
598
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 6);
3833
599
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3834
600
        verifyItem(0, 50., 75., false, "Agressive", false);
3835
601
        verifyItem(1, 125, 75., false, "Regular", false);
3836
602
        verifyItem(2, 200, 75., false, "Mild", false);
3837
603
        verifyItem(3, 275, 75., false, "Bold", false);
3838
604
        verifyItem(4, 350, 35., false, QString(), true);
3839
605
        verifyItem(5, 385, 75., false, "Lazy", false);
3840
606
        QCOMPARE(lvwph->m_minYExtent, 0.);
3841
607
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3842
608
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3843
609
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3844
610
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3845
611
        QCOMPARE(lvwph->contentY(), 0.);
3846
612
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3847
613
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3848
614
    }
3849
615
3850
616
    void testSetEmptyHeaderAtTop()
3851
617
    {
3852
618
        lvwph->setHeader(nullptr);
3853
619
3854
620
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3855
621
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3856
622
        verifyItem(0, 0., 190., false, "Agressive", false);
3857
623
        verifyItem(1, 190., 240., false, "Regular", false);
3858
624
        verifyItem(2, 430., 390., false, "Mild", false);
3859
625
        QCOMPARE(lvwph->m_minYExtent, 0.);
3860
626
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3861
627
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3862
628
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
3863
629
        QCOMPARE(lvwph->contentY(), 0.);
3864
630
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3865
631
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3866
632
    }
3867
633
3868
634
    void testSetEmptyHeaderAtBottom()
3869
635
    {
3870
636
        scrollToBottom();
3871
637
        lvwph->setHeader(nullptr);
3872
638
3873
639
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3874
640
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3875
641
        verifyItem(0, -588., 390., true, "Bold", true);
3876
642
        verifyItem(1, -198, 350., false, QString(), true);
3877
643
        verifyItem(2, 152, 390., false, "Lazy", false);
3878
644
        QCOMPARE(lvwph->m_minYExtent, 260.);
3879
645
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
3880
646
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3881
647
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
3882
648
        QCOMPARE(lvwph->contentY(), 1458.);
3883
649
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3884
650
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3885
651
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3886
652
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3887
653
3888
654
        scrollToTop();
3889
655
3890
656
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3891
657
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3892
658
        verifyItem(0, 0., 190., false, "Agressive", false);
3893
659
        verifyItem(1, 190., 240., false, "Regular", false);
3894
660
        verifyItem(2, 430., 390., false, "Mild", false);
3895
661
        QCOMPARE(lvwph->m_minYExtent, -50.);
3896
662
        QCOMPARE(lvwph->m_clipItem->y(), 50.);
3897
663
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3898
664
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
3899
665
        QCOMPARE(lvwph->contentY(), 50.);
3900
666
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3901
667
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3902
668
    }
3903
669
3904
670
    void testSetEmptyHeaderWhenPartlyShownClipped()
3905
671
    {
3906
672
        scrollToBottom();
3907
673
        changeContentY(-30);
3908
674
        lvwph->setHeader(nullptr);
3909
675
3910
676
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3911
677
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
3912
678
        verifyItem(0, -588., 390., true, "Bold", true);
3913
679
        verifyItem(1, -198, 350., false, QString(), true);
3914
680
        verifyItem(2, 152, 390., false, "Lazy", false);
3915
681
        QCOMPARE(lvwph->m_minYExtent, 290.);
3916
682
        QCOMPARE(lvwph->m_clipItem->y(), 1428.);
3917
683
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3918
684
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
3919
685
        QCOMPARE(lvwph->contentY(), 1428.);
3920
686
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3921
687
        QTRY_VERIFY(lvwph->isAtYEnd());
3922
688
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3923
689
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
3924
690
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3925
691
3926
692
        scrollToTop();
3927
693
3928
694
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3929
695
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3930
696
        verifyItem(0, 0., 190., false, "Agressive", false);
3931
697
        verifyItem(1, 190., 240., false, "Regular", false);
3932
698
        verifyItem(2, 430., 390., false, "Mild", false);
3933
699
        QCOMPARE(lvwph->m_minYExtent, -20.);
3934
700
        QCOMPARE(lvwph->m_clipItem->y(), 20.);
3935
701
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3936
702
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
3937
703
        QCOMPARE(lvwph->contentY(), 20.);
3938
704
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3939
705
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3940
706
    }
3941
707
3942
708
    void testSetEmptyHeaderWhenPartlyShownNotClipped()
3943
709
    {
3944
710
        changeContentY(30);
3945
711
        lvwph->setHeader(nullptr);
3946
712
3947
713
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
3948
714
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3949
715
        verifyItem(0, -30., 190., false, "Agressive", true);
3950
716
        verifyItem(1, 160., 240., false, "Regular", false);
3951
717
        verifyItem(2, 400., 390., false, "Mild", false);
3952
718
        QCOMPARE(lvwph->m_minYExtent, 0.);
3953
719
        QCOMPARE(lvwph->m_clipItem->y(), 30.);
3954
720
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3955
721
        QCOMPARE(lvwph->m_headerItem, (QQuickItem*)nullptr);
3956
722
        QCOMPARE(lvwph->contentY(), 30.);
3957
723
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3958
724
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3959
725
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));
3960
726
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
3961
727
    }
3962
728
3963
729
    void testSetNullDelegate()
3964
730
    {
3965
731
        lvwph->setDelegate(nullptr);
3966
732
3967
733
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 0);
3968
734
        QCOMPARE(lvwph->m_firstVisibleIndex, -1);
3969
735
        QCOMPARE(lvwph->m_minYExtent, 0.);
3970
736
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3971
737
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3972
738
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3973
739
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3974
740
        QCOMPARE(lvwph->contentY(), 0.);
3975
741
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
3976
742
        QTRY_COMPARE(lvwph->contentHeight(), 50.);
3977
743
        QVERIFY(lvwph->isAtYBeginning());
3978
744
        QVERIFY(lvwph->isAtYEnd());
3979
745
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
3980
746
    }
3981
747
3982
748
    void testInsertItems()
3983
749
    {
3984
750
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));
3985
751
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
3986
752
3987
753
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
3988
754
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
3989
755
        verifyItem(0, 50., 190., false, "Agressive", false);
3990
756
        verifyItem(1, 240., 165., false, "Regular", false);
3991
757
        verifyItem(2, 405., 140., false, "Agressive", false);
3992
758
        verifyItem(3, 545., 240., true, "Regular", true);
3993
759
        verifyItem(4, 785., 390., true, "Mild", true);
3994
760
        QCOMPARE(lvwph->m_minYExtent, 0.);
3995
761
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
3996
762
        QCOMPARE(lvwph->m_clipItem->clip(), false);
3997
763
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
3998
764
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
3999
765
        QCOMPARE(lvwph->contentY(), 0.);
4000
766
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4001
767
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4002
768
    }
4003
769
4004
770
    void testInsertItemsStealSectionItem()
4005
771
    {
4006
772
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
4007
773
4008
774
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4009
775
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4010
776
        verifyItem(0, 50., 190., false, "Agressive", false);
4011
777
        verifyItem(1, 240., 165., false, "Regular", false);
4012
778
        verifyItem(2, 405., 200., false, QString(), true);
4013
779
        verifyItem(3, 605., 390., true, "Mild", true);
4014
780
        QCOMPARE(lvwph->m_minYExtent, 0.);
4015
781
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
4016
782
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4017
783
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4018
784
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4019
785
        QCOMPARE(lvwph->contentY(), 0.);
4020
786
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4021
787
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4022
788
    }
4023
789
4024
790
4025
791
    void testInsertItemsOnNotShownPosition()
4026
792
    {
4027
793
        changeContentY(800);
4028
794
4029
795
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4030
796
        QTRY_COMPARE(lvwph->m_firstVisibleIndex, 2);
4031
797
        verifyItem(0, -320., 390., false, "Mild", true);
4032
798
        verifyItem(1, 70, 390., false, "Bold", false);
4033
799
        verifyItem(2, 460, 350., false, QString(), false);
4034
800
        verifyItem(3, 810, 390., true, "Lazy", true);
4035
801
        QCOMPARE(lvwph->m_minYExtent, 330.);
4036
802
        QCOMPARE(lvwph->m_clipItem->y(), 800.);
4037
803
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4038
804
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4039
805
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4040
806
        QCOMPARE(lvwph->contentY(), 800.);
4041
807
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4042
808
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4043
809
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4044
810
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4045
811
4046
812
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));
4047
813
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
4048
814
4049
815
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4050
816
        QCOMPARE(lvwph->m_firstVisibleIndex, 4);
4051
817
        verifyItem(0, -320., 390., false, "Mild", true);
4052
818
        verifyItem(1, 70, 390., false, "Bold", false);
4053
819
        verifyItem(2, 460, 350., false, QString(), false);
4054
820
        verifyItem(3, 810, 390., true, "Lazy", true);
4055
821
        QCOMPARE(lvwph->m_minYExtent, 1090.);
4056
822
        QCOMPARE(lvwph->m_clipItem->y(), 800.);
4057
823
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4058
824
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4059
825
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4060
826
        QCOMPARE(lvwph->contentY(), 800.);
4061
827
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4062
828
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4063
829
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4064
830
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4065
831
4066
832
        scrollToTop();
4067
833
4068
834
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
4069
835
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4070
836
        verifyItem(0, 50., 190., false, "Agressive", false);
4071
837
        verifyItem(1, 240., 165., false, "Regular", false);
4072
838
        verifyItem(2, 405., 140., false, "Agressive", false);
4073
839
        verifyItem(3, 545., 240., true, "Regular", true);
4074
840
        verifyItem(4, 785., 390., true, "Mild", true);
4075
841
        QCOMPARE(lvwph->m_minYExtent, 305.);
4076
842
        QCOMPARE(lvwph->m_clipItem->y(), -305.);
4077
843
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4078
844
        QCOMPARE(lvwph->m_headerItem->y(), -305.);
4079
845
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4080
846
        QCOMPARE(lvwph->contentY(), -305.);
4081
847
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4082
848
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4083
849
    }
4084
850
4085
851
    void testInsertItemsAtEndOfViewport()
4086
852
    {
4087
853
        changeContentY(60);
4088
854
4089
855
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4090
856
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4091
857
        verifyItem(0, -10., 190., false, "Agressive", true);
4092
858
        verifyItem(1, 180., 240., false, "Regular", false);
4093
859
        verifyItem(2, 420., 390., false, "Mild", false);
4094
860
        verifyItem(3, 810., 390., true, "Bold", true);
4095
861
        QCOMPARE(lvwph->m_minYExtent, 0.);
4096
862
        QCOMPARE(lvwph->m_clipItem->y(), 60.);
4097
863
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4098
864
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4099
865
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4100
866
        QCOMPARE(lvwph->contentY(), 60.);
4101
867
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4102
868
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4103
869
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));
4104
870
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4105
871
4106
872
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 3), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));
4107
873
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 3), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
4108
874
4109
875
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4110
876
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4111
877
        verifyItem(0, -10., 190., false, "Agressive", true);
4112
878
        verifyItem(1, 180., 240., false, "Regular", false);
4113
879
        verifyItem(2, 420., 390., false, "Mild", false);
4114
880
        verifyItem(3, 810., 165., true, "Regular", true);
4115
881
        QCOMPARE(lvwph->m_minYExtent, 0.);
4116
882
        QCOMPARE(lvwph->m_clipItem->y(), 60.);
4117
883
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4118
884
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4119
885
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4120
886
        QCOMPARE(lvwph->contentY(), 60.);
4121
887
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4122
888
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4123
889
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Agressive"));
4124
890
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4125
891
    }
4126
892
4127
893
    void testInsertItemsBeforeValidIndex()
4128
894
    {
4129
895
        changeContentY(520);
4130
896
4131
897
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4132
898
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
4133
899
        verifyItem(0, -280., 240., true, "Regular", true);
4134
900
        verifyItem(1, -40, 390., false, "Mild", true);
4135
901
        verifyItem(2, 350, 390., false, "Bold", false);
4136
902
        verifyItem(3, 740, 350., true, QString(), true);
4137
903
        QCOMPARE(lvwph->m_minYExtent, 152.5);
4138
904
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
4139
905
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4140
906
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4141
907
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4142
908
        QCOMPARE(lvwph->contentY(), 520.);
4143
909
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4144
910
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4145
911
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4146
912
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4147
913
4148
914
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));
4149
915
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
4150
916
4151
917
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4152
918
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
4153
919
        verifyItem(0, -280., 240., true, "Regular", true);
4154
920
        verifyItem(1, -40, 390., false, "Mild", true);
4155
921
        verifyItem(2, 350, 390., false, "Bold", false);
4156
922
        verifyItem(3, 740, 350., true, QString(), true);
4157
923
        QCOMPARE(lvwph->m_minYExtent, 837.5);
4158
924
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
4159
925
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4160
926
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4161
927
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4162
928
        QCOMPARE(lvwph->contentY(), 520.);
4163
929
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4164
930
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4165
931
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4166
932
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4167
933
    }
4168
934
4169
935
    void testInsertItemsBeforeViewport()
4170
936
    {
4171
937
        changeContentY(375);
4172
938
4173
939
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4174
940
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4175
941
        verifyItem(0, -325., 190., true, "Agressive", true);
4176
942
        verifyItem(1, -135, 240., false, "Regular", true);
4177
943
        verifyItem(2, 105, 390., false, "Mild", false);
4178
944
        verifyItem(3, 495, 390., false, "Bold", false);
4179
945
        QCOMPARE(lvwph->m_minYExtent, 0.);
4180
946
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
4181
947
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4182
948
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4183
949
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4184
950
        QCOMPARE(lvwph->contentY(), 375.);
4185
951
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4186
952
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4187
953
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
4188
954
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4189
955
4190
956
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));
4191
957
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
4192
958
4193
959
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4194
960
        QCOMPARE(lvwph->m_firstVisibleIndex, 2);
4195
961
        verifyItem(0, -275., 140., true, "Agressive", true);
4196
962
        verifyItem(1, -135., 240., false, "Regular", true);
4197
963
        verifyItem(2, 105, 390., false, "Mild", false);
4198
964
        verifyItem(3, 495, 390., false, "Bold", false);
4199
965
        QCOMPARE(lvwph->m_minYExtent, 530.);
4200
966
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
4201
967
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4202
968
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4203
969
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4204
970
        QCOMPARE(lvwph->contentY(), 375.);
4205
971
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4206
972
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4207
973
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
4208
974
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4209
975
4210
976
        scrollToTop();
4211
977
4212
978
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
4213
979
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4214
980
        verifyItem(0, 50., 190., false, "Agressive", false);
4215
981
        verifyItem(1, 240., 165., false, "Regular", false);
4216
982
        verifyItem(2, 405., 140., false, "Agressive", false);
4217
983
        verifyItem(3, 545., 240., true, "Regular", true);
4218
984
        verifyItem(4, 785., 390., true, "Mild", true);
4219
985
        QCOMPARE(lvwph->m_minYExtent, 305.);
4220
986
        QCOMPARE(lvwph->m_clipItem->y(), -305.);
4221
987
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4222
988
        QCOMPARE(lvwph->m_headerItem->y(), -305.);
4223
989
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4224
990
        QCOMPARE(lvwph->contentY(), -305.);
4225
991
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4226
992
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4227
993
    }
4228
994
4229
995
    void testInsertItemsAtBottom()
4230
996
    {
4231
997
        scrollToBottom();
4232
998
4233
999
        QVERIFY(lvwph->isAtYEnd());
4234
1000
4235
1001
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 100), Q_ARG(QVariant, "Agressive"));
4236
1002
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 125), Q_ARG(QVariant, "Regular"));
4237
1003
4238
1004
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
4239
1005
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
4240
1006
        verifyItem(0, -588., 390., true, "Bold", true);
4241
1007
        verifyItem(1, -198, 350., false, QString(), true);
4242
1008
        verifyItem(2, 152, 390., false, "Lazy", false);
4243
1009
        verifyItem(3, 542, 165., true, "Regular", true);
4244
1010
        verifyItem(4, 707, 140., true, "Agressive", true);
4245
1011
        QCOMPARE(lvwph->m_minYExtent, 41.);
4246
1012
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
4247
1013
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4248
1014
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4249
1015
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4250
1016
        QCOMPARE(lvwph->contentY(), 1458.);
4251
1017
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4252
1018
        QVERIFY(!lvwph->isAtYEnd());
4253
1019
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4254
1020
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
4255
1021
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4256
1022
4257
1023
        scrollToBottom();
4258
1024
4259
1025
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4260
1026
        QCOMPARE(lvwph->m_firstVisibleIndex, 4);
4261
1027
        verifyItem(0, -503., 350., true, QString(), true);
4262
1028
        verifyItem(1, -153, 390., false, "Lazy", true);
4263
1029
        verifyItem(2, 237, 165., false, "Regular", false);
4264
1030
        verifyItem(3, 402, 140., false, "Agressive", false);
4265
1031
        QCOMPARE(lvwph->m_minYExtent, -165.);
4266
1032
        QCOMPARE(lvwph->m_clipItem->y(), 1763.);
4267
1033
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4268
1034
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4269
1035
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4270
1036
        QCOMPARE(lvwph->contentY(), 1763.);
4271
1037
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4272
1038
        QVERIFY(lvwph->isAtYEnd());
4273
1039
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4274
1040
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Lazy"));
4275
1041
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4276
1042
    }
4277
1043
4278
1044
    void testInsertItemAtTop()
4279
1045
    {
4280
1046
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4281
1047
4282
1048
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4283
1049
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4284
1050
        verifyItem(0, 50., 115., false, "Agressive", false);
4285
1051
        verifyItem(1, 165., 150., false, QString(), false);
4286
1052
        verifyItem(2, 315., 240., false, "Regular", false);
4287
1053
        verifyItem(3, 555., 390., true, "Mild", true);
4288
1054
        QCOMPARE(lvwph->m_minYExtent, 0.);
4289
1055
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
4290
1056
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4291
1057
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4292
1058
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4293
1059
        QCOMPARE(lvwph->contentY(), 0.);
4294
1060
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4295
1061
        QVERIFY(lvwph->isAtYBeginning());
4296
1062
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4297
1063
    }
4298
1064
4299
1065
    void testInsertItem10SmallItemsAtTopWhenAtBottom()
4300
1066
    {
4301
1067
        scrollToBottom();
4302
1068
4303
1069
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4304
1070
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4305
1071
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4306
1072
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Regular"));
4307
1073
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Regular"));
4308
1074
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Regular"));
4309
1075
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4310
1076
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4311
1077
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Regular"));
4312
1078
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 75), Q_ARG(QVariant, "Agressive"));
4313
1079
4314
1080
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4315
1081
        QCOMPARE(lvwph->m_firstVisibleIndex, 13);
4316
1082
        verifyItem(0, -588., 390., true, "Bold", true);
4317
1083
        verifyItem(1, -198, 350., false, QString(), true);
4318
1084
        verifyItem(2, 152, 390., false, "Lazy", false);
4319
1085
        QCOMPARE(lvwph->m_minYExtent, 12230./3.);
4320
1086
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
4321
1087
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4322
1088
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4323
1089
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4324
1090
        QCOMPARE(lvwph->contentY(), 1458.);
4325
1091
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4326
1092
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4327
1093
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
4328
1094
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4329
1095
4330
1096
        changeContentY(-1700);
4331
1097
4332
1098
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 10);
4333
1099
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
4334
1100
        verifyItem(0, -323., 75., true, QString(), true);
4335
1101
        verifyItem(1, -248., 115., true, "Regular", true);
4336
1102
        verifyItem(2, -133., 75., true, QString(), true);
4337
1103
        verifyItem(3, -58., 75., false, QString(), true);
4338
1104
        verifyItem(4, 17., 115., false, "Agressive", false);
4339
1105
        verifyItem(5, 132., 75., false, QString(), true);
4340
1106
        verifyItem(6, 207., 75., false, QString(), true);
4341
1107
        verifyItem(7, 282., 150., false, QString(), true);
4342
1108
        verifyItem(8, 432., 240., false, "Regular", false);
4343
1109
        QCOMPARE(lvwph->m_minYExtent, 980.5);
4344
1110
        QCOMPARE(lvwph->m_clipItem->y(), -192.);
4345
1111
        QCOMPARE(lvwph->m_clipItem->clip(), true);
4346
1112
        QCOMPARE(lvwph->m_headerItem->y(), -242.);
4347
1113
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4348
1114
        QCOMPARE(lvwph->contentY(), -242.);
4349
1115
        QCOMPARE(lvwph->m_headerItemShownHeight, 50.);
4350
1116
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4351
1117
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
4352
1118
        QCOMPARE(lvwph->m_topSectionItem->y(), -23.);
4353
1119
    }
4354
1120
4355
1121
    void testRemoveItemsAtTop()
4356
1122
    {
4357
1123
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));
4358
1124
4359
1125
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 2);
4360
1126
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4361
1127
        verifyItem(0, 50., 390., false, "Mild", false);
4362
1128
        verifyItem(1, 440., 390., false, "Bold", false);
4363
1129
        QCOMPARE(lvwph->m_minYExtent, 0.);
4364
1130
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
4365
1131
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4366
1132
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4367
1133
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4368
1134
        QCOMPARE(lvwph->contentY(), 0.);
4369
1135
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4370
1136
        QVERIFY(lvwph->isAtYBeginning());
4371
1137
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4372
1138
    }
4373
1139
4374
1140
    void testRemoveNonCreatedItemsAtTopWhenAtBottom()
4375
1141
    {
4376
1142
        scrollToBottom();
4377
1143
4378
1144
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 2));
4379
1145
4380
1146
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4381
1147
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
4382
1148
        verifyItem(0, -588., 390., true, "Bold", true);
4383
1149
        verifyItem(1, -198, 350., false, QString(), true);
4384
1150
        verifyItem(2, 152, 390., false, "Lazy", false);
4385
1151
        QCOMPARE(lvwph->m_minYExtent, -1330./3.);
4386
1152
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
4387
1153
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4388
1154
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4389
1155
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4390
1156
        QCOMPARE(lvwph->contentY(), 1458.);
4391
1157
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4392
1158
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4393
1159
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
4394
1160
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4395
1161
    }
4396
1162
4397
1163
    void testRemoveLastItemsAtBottom()
4398
1164
    {
4399
1165
        scrollToBottom();
4400
1166
4401
1167
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 4), Q_ARG(QVariant, 2));
4402
1168
4403
1169
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4404
1170
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
4405
1171
        verifyItem(0, -478., 240., true, "Regular", true);
4406
1172
        verifyItem(1, -238, 390., false, "Mild", true);
4407
1173
        verifyItem(2, 152, 390., false, "Bold", false);
4408
1174
        QCOMPARE(lvwph->m_minYExtent, 150.);
4409
1175
        QCOMPARE(lvwph->m_clipItem->y(), 718.);
4410
1176
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4411
1177
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4412
1178
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4413
1179
        QCOMPARE(lvwph->contentY(), 718.);
4414
1180
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4415
1181
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4416
1182
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4417
1183
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4418
1184
    }
4419
1185
4420
1186
    void testRemoveItemOutOfViewport()
4421
1187
    {
4422
1188
        changeContentY(520);
4423
1189
4424
1190
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4425
1191
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
4426
1192
        verifyItem(0, -280., 240., true, "Regular", true);
4427
1193
        verifyItem(1, -40, 390., false, "Mild", true);
4428
1194
        verifyItem(2, 350, 390., false, "Bold", false);
4429
1195
        verifyItem(3, 740, 350., true, QString(), true);
4430
1196
        QCOMPARE(lvwph->m_minYExtent, 152.5);
4431
1197
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
4432
1198
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4433
1199
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4434
1200
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4435
1201
        QCOMPARE(lvwph->contentY(), 520.);
4436
1202
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4437
1203
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4438
1204
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4439
1205
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4440
1206
4441
1207
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));
4442
1208
4443
1209
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4444
1210
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4445
1211
        verifyItem(0, -230., 190., true, "Agressive", true);
4446
1212
        verifyItem(1, -40, 390., false, "Mild", true);
4447
1213
        verifyItem(2, 350, 390., false, "Bold", false);
4448
1214
        verifyItem(3, 740, 350., true, QString(), true);
4449
1215
        QCOMPARE(lvwph->m_minYExtent, -240.);
4450
1216
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
4451
1217
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4452
1218
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4453
1219
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4454
1220
        QCOMPARE(lvwph->contentY(), 520.);
4455
1221
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4456
1222
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4457
1223
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4458
1224
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4459
1225
    }
4460
1226
4461
1227
    void testRemoveFirstOfCategory()
4462
1228
    {
4463
1229
        changeContentY(520);
4464
1230
4465
1231
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4466
1232
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
4467
1233
        verifyItem(0, -280., 240., true, "Regular", true);
4468
1234
        verifyItem(1, -40, 390., false, "Mild", true);
4469
1235
        verifyItem(2, 350, 390., false, "Bold", false);
4470
1236
        verifyItem(3, 740, 350., true, QString(), true);
4471
1237
        QCOMPARE(lvwph->m_minYExtent, 152.5);
4472
1238
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
4473
1239
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4474
1240
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4475
1241
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4476
1242
        QCOMPARE(lvwph->contentY(), 520.);
4477
1243
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4478
1244
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4479
1245
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4480
1246
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4481
1247
4482
1248
        QMetaObject::invokeMethod(model, "removeItems", Q_ARG(QVariant, 3), Q_ARG(QVariant, 1));
4483
1249
4484
1250
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4485
1251
        QCOMPARE(lvwph->m_firstVisibleIndex, 1);
4486
1252
        verifyItem(0, -280., 240., true, "Regular", true);
4487
1253
        verifyItem(1, -40, 390., false, "Mild", true);
4488
1254
        verifyItem(2, 350, 390., false, "Bold", false);
4489
1255
        verifyItem(3, 740, 390., true, "Lazy", true);
4490
1256
        QCOMPARE(lvwph->m_minYExtent, 162.5);
4491
1257
        QCOMPARE(lvwph->m_clipItem->y(), 520.);
4492
1258
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4493
1259
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4494
1260
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4495
1261
        QCOMPARE(lvwph->contentY(), 520.);
4496
1262
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4497
1263
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4498
1264
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4499
1265
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4500
1266
    }
4501
1267
4502
1268
    void testAddSecondToCulledCategoryOfTwo()
4503
1269
    {
4504
1270
        // Do some setup
4505
1271
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));
4506
1272
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 0), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));
4507
1273
4508
1274
        changeContentY(200);
4509
1275
4510
1276
        // Very the items are culled
4511
1277
        verifyItem(0, -150., 65., true, "Agressive", true);
4512
1278
        verifyItem(1, -85, 25., true, QString(), true);
4513
1279
4514
1280
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 1), Q_ARG(QVariant, 25), Q_ARG(QVariant, "Agressive"));
4515
1281
4516
1282
        // Very the new item is there correctly
4517
1283
        verifyItem(0, -175., 65., true, "Agressive", true);
4518
1284
        verifyItem(1, -110, 25., true, QString(), true);
4519
1285
        verifyItem(2, -85, 25., true, QString(), true);
4520
1286
    }
4521
1287
4522
1288
    void testMoveFirstItems()
4523
1289
    {
4524
1290
        QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 1), Q_ARG(QVariant, 1));
4525
1291
4526
1292
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4527
1293
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4528
1294
        verifyItem(0, 50., 240., false, "Regular", false);
4529
1295
        verifyItem(1, 290., 190., false, "Agressive", false);
4530
1296
        verifyItem(2, 480., 390., false, "Mild", false);
4531
1297
        QCOMPARE(lvwph->m_minYExtent, 0.);
4532
1298
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
4533
1299
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4534
1300
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4535
1301
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4536
1302
        QCOMPARE(lvwph->contentY(), 0.);
4537
1303
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4538
1304
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4539
1305
    }
4540
1306
4541
1307
    void testMoveFirstOutOfVisibleItems()
4542
1308
    {
4543
1309
        QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 4), Q_ARG(QVariant, 1));
4544
1310
4545
1311
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4546
1312
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4547
1313
        verifyItem(0, 50., 240., false, "Regular", false);
4548
1314
        verifyItem(1, 290., 390., false, "Mild", false);
4549
1315
        verifyItem(2, 680., 390., true, "Bold", true);
4550
1316
        QCOMPARE(lvwph->m_minYExtent, 0.);
4551
1317
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
4552
1318
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4553
1319
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4554
1320
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4555
1321
        QCOMPARE(lvwph->contentY(), 0.);
4556
1322
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4557
1323
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4558
1324
    }
4559
1325
4560
1326
    void testMoveFirstToLastAtBottom()
4561
1327
    {
4562
1328
        scrollToBottom();
4563
1329
4564
1330
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4565
1331
        QCOMPARE(lvwph->m_firstVisibleIndex, 3);
4566
1332
        verifyItem(0, -588., 390., true, "Bold", true);
4567
1333
        verifyItem(1, -198, 350., false, QString(), true);
4568
1334
        verifyItem(2, 152, 390., false, "Lazy", false);
4569
1335
        QCOMPARE(lvwph->m_minYExtent, 310.);
4570
1336
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
4571
1337
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4572
1338
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4573
1339
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4574
1340
        QCOMPARE(lvwph->contentY(), 1458.);
4575
1341
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4576
1342
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4577
1343
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
4578
1344
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4579
1345
4580
1346
        QMetaObject::invokeMethod(model, "moveItems", Q_ARG(QVariant, 0), Q_ARG(QVariant, 5), Q_ARG(QVariant, 1));
4581
1347
4582
1348
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4583
1349
        QCOMPARE(lvwph->m_firstVisibleIndex, 2);
4584
1350
        verifyItem(0, -588., 390., true, "Bold", true);
4585
1351
        verifyItem(1, -198, 350., false, QString(), true);
4586
1352
        verifyItem(2, 152, 390., false, "Lazy", false);
4587
1353
        verifyItem(3, 542, 190., true, "Agressive", true);
4588
1354
        QCOMPARE(lvwph->m_minYExtent, -160.);
4589
1355
        QCOMPARE(lvwph->m_clipItem->y(), 1458.);
4590
1356
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4591
1357
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4592
1358
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4593
1359
        QCOMPARE(lvwph->contentY(), 1458.);
4594
1360
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4595
1361
        QVERIFY(!lvwph->isAtYEnd());
4596
1362
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4597
1363
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Bold"));
4598
1364
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4599
1365
    }
4600
1366
4601
1367
    void testChangeSizeVisibleItemNotOnViewport()
4602
1368
    {
4603
1369
        changeContentY(490);
4604
1370
4605
1371
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
4606
1372
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4607
1373
        verifyItem(0, -440., 190., true, "Agressive", true);
4608
1374
        verifyItem(1, -250., 240., true, "Regular", true);
4609
1375
        verifyItem(2, -10, 390., false, "Mild", true);
4610
1376
        verifyItem(3, 380, 390., false, "Bold", false);
4611
1377
        verifyItem(4, 770, 350., true, QString(), true);
4612
1378
        QCOMPARE(lvwph->m_minYExtent, 0.);
4613
1379
        QCOMPARE(lvwph->m_clipItem->y(), 490.);
4614
1380
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4615
1381
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4616
1382
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4617
1383
        QCOMPARE(lvwph->contentY(), 490.);
4618
1384
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4619
1385
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4620
1386
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4621
1387
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4622
1388
4623
1389
        model->setProperty(1, "size", 100);
4624
1390
4625
1391
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
4626
1392
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4627
1393
        verifyItem(0, -340., 190., true, "Agressive", true);
4628
1394
        verifyItem(1, -150., 140., true, "Regular", true);
4629
1395
        verifyItem(2, -10, 390., false, "Mild", true);
4630
1396
        verifyItem(3, 380, 390., false, "Bold", false);
4631
1397
        verifyItem(4, 770, 350., true, QString(), true);
4632
1398
        QCOMPARE(lvwph->m_minYExtent, -100.);
4633
1399
        QCOMPARE(lvwph->m_clipItem->y(), 490.);
4634
1400
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4635
1401
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4636
1402
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4637
1403
        QCOMPARE(lvwph->contentY(), 490.);
4638
1404
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4639
1405
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4640
1406
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Mild"));
4641
1407
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4642
1408
    }
4643
1409
4644
1410
    void testShowHeaderCloseToTheTop()
4645
1411
    {
4646
1412
        changeContentY(375);
4647
1413
4648
1414
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4649
1415
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4650
1416
        verifyItem(0, -325., 190., true, "Agressive", true);
4651
1417
        verifyItem(1, -135, 240., false, "Regular", true);
4652
1418
        verifyItem(2, 105, 390., false, "Mild", false);
4653
1419
        verifyItem(3, 495, 390., false, "Bold", false);
4654
1420
        QCOMPARE(lvwph->m_minYExtent, 0.);
4655
1421
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
4656
1422
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4657
1423
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4658
1424
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4659
1425
        QCOMPARE(lvwph->contentY(), 375.);
4660
1426
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);;
4661
1427
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4662
1428
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
4663
1429
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4664
1430
4665
1431
        lvwph->showHeader();
4666
1432
4667
1433
        QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());
4668
1434
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 4);
4669
1435
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4670
1436
        verifyItem(0, -375., 190., true, "Agressive", true);
4671
1437
        verifyItem(1, -185, 240., false, "Regular", true);
4672
1438
        verifyItem(2, 55, 390., false, "Mild", false);
4673
1439
        verifyItem(3, 445, 390., false, "Bold", false);
4674
1440
        QCOMPARE(lvwph->m_minYExtent, 50.);
4675
1441
        QCOMPARE(lvwph->m_clipItem->y(), 375.);
4676
1442
        QCOMPARE(lvwph->m_clipItem->clip(), true);
4677
1443
        QCOMPARE(lvwph->m_headerItem->y(), 325.);
4678
1444
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4679
1445
        QCOMPARE(lvwph->contentY(), 325.);
4680
1446
        QCOMPARE(lvwph->m_headerItemShownHeight, 50.);
4681
1447
        QVERIFY(!QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4682
1448
        QCOMPARE(section(lvwph->m_topSectionItem), QString("Regular"));
4683
1449
        QCOMPARE(lvwph->m_topSectionItem->y(), 0.);
4684
1450
4685
1451
        scrollToTop();
4686
1452
4687
1453
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 3);
4688
1454
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4689
1455
        verifyItem(0, 50., 190., false, "Agressive", false);
4690
1456
        verifyItem(1, 240., 240., false, "Regular", false);
4691
1457
        verifyItem(2, 480., 390., false, "Mild", false);
4692
1458
        QCOMPARE(lvwph->m_minYExtent, 50.);
4693
1459
        QCOMPARE(lvwph->m_clipItem->y(), -50.);
4694
1460
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4695
1461
        QCOMPARE(lvwph->m_headerItem->y(), -50.);
4696
1462
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4697
1463
        QCOMPARE(lvwph->contentY(), -50.);
4698
1464
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4699
1465
        QVERIFY(QQuickItemPrivate::get(lvwph->m_topSectionItem)->culled);
4700
1466
    }
4701
1467
4702
1468
    void testShowHeaderAtBottom()
4703
1469
    {
4704
1470
        scrollToBottom();
4705
1471
4706
1472
        lvwph->showHeader();
4707
1473
4708
1474
        QTRY_VERIFY(!lvwph->m_headerShowAnimation->isRunning());
4709
1475
        QTRY_VERIFY (lvwph->isAtYEnd());
4710
1476
    }
4711
1477
4712
1478
    void growWindow()
4713
1479
    {
4714
1480
        view->rootObject()->setHeight(850);
4715
1481
4716
1482
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 5);
4717
1483
        QCOMPARE(lvwph->m_firstVisibleIndex, 0);
4718
1484
        verifyItem(0, 50., 190., false, "Agressive", false);
4719
1485
        verifyItem(1, 240., 240., false, "Regular", false);
4720
1486
        verifyItem(2, 480., 390., false, "Mild", false);
4721
1487
        verifyItem(3, 870., 390., true, "Bold", true);
4722
1488
        verifyItem(4, 1260., 350., true, QString(), true);
4723
1489
        QCOMPARE(lvwph->m_minYExtent, 0.);
4724
1490
        QCOMPARE(lvwph->m_clipItem->y(), 0.);
4725
1491
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4726
1492
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4727
1493
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4728
1494
        QCOMPARE(lvwph->contentY(), 0.);
4729
1495
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4730
1496
    }
4731
1497
4732
1498
    void growWindowAtBottom()
4733
1499
    {
4734
1500
        // Need a bunch small items at the bottom to trigger the problem
4735
1501
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4736
1502
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4737
1503
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4738
1504
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4739
1505
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4740
1506
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4741
1507
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));
4742
1508
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));
4743
1509
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));
4744
1510
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));
4745
1511
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));
4746
1512
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Regular"));
4747
1513
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4748
1514
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4749
1515
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4750
1516
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4751
1517
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4752
1518
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4753
1519
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4754
1520
        QMetaObject::invokeMethod(model, "insertItem", Q_ARG(QVariant, 6), Q_ARG(QVariant, 50), Q_ARG(QVariant, "Agressive"));
4755
1521
4756
1522
        scrollToBottom();
4757
1523
4758
1524
        view->rootObject()->setHeight(850);
4759
1525
4760
1526
        QTRY_COMPARE(lvwph->m_visibleItems.count(), 21);
4761
1527
        QCOMPARE(lvwph->m_firstVisibleIndex, 5);
4762
1528
        verifyItem(0, -660., 390., true, "Lazy", true);
4763
1529
        verifyItem(1, -270., 90., true, "Agressive", true);
4764
1530
        verifyItem(2, -180, 50., true, QString(), true);
4765
1531
        verifyItem(3, -130, 50., true, QString(), true);
4766
1532
        verifyItem(4, -80, 50., true, QString(), true);
4767
1533
        verifyItem(5, -30, 50., false, QString(), true);
4768
1534
        verifyItem(6, 20, 50., false, QString(), true);
4769
1535
        verifyItem(7, 70, 50., false, QString(), true);
4770
1536
        verifyItem(8, 120, 50., false, QString(), true);
4771
1537
        verifyItem(9, 170, 90., false, "Regular", false);
4772
1538
        verifyItem(10, 260, 50., false, QString(), true);
4773
1539
        verifyItem(11, 310, 50., false, QString(), true);
4774
1540
        verifyItem(12, 360, 50., false, QString(), true);
4775
1541
        verifyItem(13, 410, 50., false, QString(), true);
4776
1542
        verifyItem(14, 460, 50., false, QString(), true);
4777
1543
        verifyItem(15, 510, 90., false, "Agressive", false);
4778
1544
        verifyItem(16, 600, 50., false, QString(), true);
4779
1545
        verifyItem(17, 650, 50., false, QString(), true);
4780
1546
        verifyItem(18, 700, 50., false, QString(), true);
4781
1547
        verifyItem(19, 750, 50., false, QString(), true);
4782
1548
        verifyItem(20, 800, 50., false, QString(), true);
4783
1549
        QCOMPARE(lvwph->m_minYExtent, 5 * 1510./21. + 660 - 1970 + 50);
4784
1550
        QCOMPARE(lvwph->m_clipItem->y(), 1970.);
4785
1551
        QCOMPARE(lvwph->m_clipItem->clip(), false);
4786
1552
        QCOMPARE(lvwph->m_headerItem->y(), 0.);
4787
1553
        QCOMPARE(lvwph->m_headerItem->height(), 50.);
4788
1554
        QCOMPARE(lvwph->contentY(), 1970.);
4789
1555
        QCOMPARE(lvwph->m_headerItemShownHeight, 0.);
4790
1556
    }
4791
1557
4792
1558
private:
4793
1559
    QQuickView *view;
4794
1560
    ListViewWithPageHeader *lvwph;
4795
1561
    QQuickListModel *model;
4796
1562
    QQmlComponent *otherDelegate;
4797
1563
};
4798
1564
4799
1565
QTEST_MAIN(ListViewWithPageHeaderTestSection)
4800
1566
4801
1567
#include "listviewwithpageheadertestsection.moc"
4802
0
1568
4803
=== added file 'tests/plugins/ListViewWithPageHeader/test.qml'
4804
--- tests/plugins/ListViewWithPageHeader/test.qml	1970-01-01 00:00:00 +0000
4805
+++ tests/plugins/ListViewWithPageHeader/test.qml	2013-07-01 11:23:32 +0000
4806
@@ -0,0 +1,96 @@
4807
1
/*
4808
2
 * Copyright (C) 2013 Canonical, Ltd.
4809
3
 *
4810
4
 * This program is free software; you can redistribute it and/or modify
4811
5
 * it under the terms of the GNU General Public License as published by
4812
6
 * the Free Software Foundation; version 3.
4813
7
 *
4814
8
 * This program is distributed in the hope that it will be useful,
4815
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4816
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4817
11
 * GNU General Public License for more details.
4818
12
 *
4819
13
 * You should have received a copy of the GNU General Public License
4820
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4821
15
 */
4822
16
4823
17
import QtQuick 2.0
4824
18
import ListViewWithPageHeader 0.1
4825
19
4826
20
Rectangle {
4827
21
    width: 300
4828
22
    height: 542
4829
23
    color: "lightblue"
4830
24
4831
25
    ListModel {
4832
26
        id: model
4833
27
4834
28
        function insertItem(index, size) {
4835
29
            insert(index, { size: size });
4836
30
        }
4837
31
4838
32
        function removeItems(index, count) {
4839
33
            remove(index, count);
4840
34
        }
4841
35
4842
36
        function moveItems(indexFrom, indexTo, count) {
4843
37
            move(indexFrom, indexTo, count);
4844
38
        }
4845
39
4846
40
        ListElement { size: 150 }
4847
41
        ListElement { size: 200 }
4848
42
        ListElement { size: 350 }
4849
43
        ListElement { size: 350 }
4850
44
        ListElement { size: 350 }
4851
45
        ListElement { size: 350 }
4852
46
    }
4853
47
4854
48
    Component {
4855
49
        id: otherRect
4856
50
        Rectangle {
4857
51
            height: 35
4858
52
            width: parent.width
4859
53
            color: index % 2 == 0 ? "yellow" : "purple"
4860
54
        }
4861
55
    }
4862
56
4863
57
    ListViewWithPageHeader {
4864
58
        id: listView
4865
59
        width: parent.width
4866
60
        anchors.top: parent.top
4867
61
        anchors.bottom: parent.bottom
4868
62
        model: model
4869
63
        delegate: Rectangle {
4870
64
            property bool timerDone: false
4871
65
            width: parent.width - 20
4872
66
            x: 10
4873
67
            color: index % 2 == 0 ? "red" : "blue"
4874
68
            height: timerDone ? size : 350
4875
69
            Text {
4876
70
                text: index
4877
71
            }
4878
72
            Timer {
4879
73
                id: sizeTimer
4880
74
                interval: 10;
4881
75
                onTriggered: {
4882
76
                    timerDone = true
4883
77
                }
4884
78
            }
4885
79
            Component.onCompleted: {
4886
80
                sizeTimer.start()
4887
81
            }
4888
82
        }
4889
83
4890
84
        pageHeader: Rectangle {
4891
85
            color: "transparent"
4892
86
            width: parent.width
4893
87
            height: 50
4894
88
            implicitHeight: 50
4895
89
            Text {
4896
90
                anchors.fill: parent
4897
91
                text: "APPS"
4898
92
                font.pixelSize: 40
4899
93
            }
4900
94
        }
4901
95
    }
4902
96
}
4903
0
97
4904
=== added file 'tests/plugins/ListViewWithPageHeader/test_section.qml'
4905
--- tests/plugins/ListViewWithPageHeader/test_section.qml	1970-01-01 00:00:00 +0000
4906
+++ tests/plugins/ListViewWithPageHeader/test_section.qml	2013-07-01 11:23:32 +0000
4907
@@ -0,0 +1,106 @@
4908
1
/*
4909
2
 * Copyright (C) 2013 Canonical, Ltd.
4910
3
 *
4911
4
 * This program is free software; you can redistribute it and/or modify
4912
5
 * it under the terms of the GNU General Public License as published by
4913
6
 * the Free Software Foundation; version 3.
4914
7
 *
4915
8
 * This program is distributed in the hope that it will be useful,
4916
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4917
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4918
11
 * GNU General Public License for more details.
4919
12
 *
4920
13
 * You should have received a copy of the GNU General Public License
4921
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4922
15
 */
4923
16
4924
17
import QtQuick 2.0
4925
18
import ListViewWithPageHeader 0.1
4926
19
4927
20
Rectangle {
4928
21
    width: 300
4929
22
    height: 542
4930
23
    color: "lightblue"
4931
24
4932
25
    ListModel {
4933
26
        id: model
4934
27
4935
28
        function insertItem(index, size, type) {
4936
29
            insert(index, { size: size, type: type });
4937
30
        }
4938
31
4939
32
        function removeItems(index, count) {
4940
33
            remove(index, count);
4941
34
        }
4942
35
4943
36
        function moveItems(indexFrom, indexTo, count) {
4944
37
            move(indexFrom, indexTo, count);
4945
38
        }
4946
39
4947
40
        ListElement { type: "Agressive"; size: 150 }
4948
41
        ListElement { type: "Regular"; size: 200 }
4949
42
        ListElement { type: "Mild"; size: 350 }
4950
43
        ListElement { type: "Bold"; size: 350 }
4951
44
        ListElement { type: "Bold"; size: 350 }
4952
45
        ListElement { type: "Lazy"; size: 350 }
4953
46
    }
4954
47
4955
48
    Component {
4956
49
        id: otherRect
4957
50
        Rectangle {
4958
51
            height: 35
4959
52
            width: parent.width
4960
53
            color: index % 2 == 0 ? "yellow" : "purple"
4961
54
        }
4962
55
    }
4963
56
4964
57
    ListViewWithPageHeader {
4965
58
        id: listView
4966
59
        width: parent.width
4967
60
        anchors.top: parent.top
4968
61
        anchors.bottom: parent.bottom
4969
62
        model: model
4970
63
        delegate: Rectangle {
4971
64
            property bool timerDone: false
4972
65
            width: parent.width - 20
4973
66
            x: 10
4974
67
            color: index % 2 == 0 ? "red" : "blue"
4975
68
            height: timerDone ? size : 350
4976
69
            Text {
4977
70
                text: index
4978
71
            }
4979
72
            Timer {
4980
73
                id: sizeTimer
4981
74
                interval: 10;
4982
75
                onTriggered: {
4983
76
                    timerDone = true
4984
77
                }
4985
78
            }
4986
79
            Component.onCompleted: {
4987
80
                sizeTimer.start()
4988
81
            }
4989
82
        }
4990
83
4991
84
        pageHeader: Rectangle {
4992
85
            color: "transparent"
4993
86
            width: parent.width
4994
87
            height: 50
4995
88
            implicitHeight: 50
4996
89
            Text {
4997
90
                anchors.fill: parent
4998
91
                text: "APPS"
4999
92
                font.pixelSize: 40
5000
93
            }
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2013-07-01
Gerry Boland (community)		2013-06-07	Approve on 2013-07-01
Review via email: mp+168073@code.launchpad.net