/*
* Copyright 2015-2016 Canonical Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see .
*
* Author: Andrea Bernabei
*/
import QtQuick
import QtTest
import Lomiri.Test
import Lomiri.Components
import Lomiri.Components.Styles
import QtQml.Models
Item {
id: main
width: units.gu(50)
height: units.gu(100)
Component {
id: flickableComp
Item {
id: item
width: units.gu(20)
height: units.gu(30)
property alias flickable: freshFlickable
property alias scrollbar: freshScrollbar
property alias content: content
property alias scrollbarAlignment: freshScrollbar.align
//Don't change this to a ListView, this usecase has to be simple,
//we don't want the difficulties added by ListView, i.e. delegates
//size estimation, dynamic contentWidth/Height, etc
Flickable {
id: freshFlickable
anchors.fill: parent
contentHeight: content.height
contentWidth: content.width
clip: true
Rectangle {
id: content
width: units.gu(40)
//make this much taller than the flickable to avoid timing issues when
//detecting if the flickable is flicking in the tests
height: units.gu(200)
color: "blue"
}
}
Scrollbar {
id: freshScrollbar
flickableItem: parent.flickable
}
}
}
Component {
id: freshScrollbar
Scrollbar { }
}
SignalSpy {
id: signalSpy
}
SignalSpy {
id: anotherSignalSpy
}
Flickable {
anchors.fill: parent
Column {
id: column
Repeater {
model: layoutsModel
}
}
}
ObjectModel {
id: layoutsModel
Item {
width: childrenRect.width
height: childrenRect.height
Flickable {
id: flickable_bottomAlign_anchors
}
Scrollbar {
id: scrollbar_bottomAlign_anchors
flickableItem: flickable_bottomAlign_anchors
align: Qt.AlignBottom
}
Flickable {
id: flickable_topAlign_anchors
}
Scrollbar {
id: scrollbar_topAlign_anchors
flickableItem: flickable_topAlign_anchors
align: Qt.AlignBottom
}
Flickable {
id: flickable_leadingAlign_anchors
}
Scrollbar {
id: scrollbar_leadingAlign_anchors
flickableItem: flickable_leadingAlign_anchors
align: Qt.AlignLeading
}
Flickable {
id: flickable_trailingAlign_anchors
}
Scrollbar {
id: scrollbar_trailingAlign_anchors
flickableItem: flickable_trailingAlign_anchors
align: Qt.AlignTrailing
}
Flickable {
id: defaultValuesFlickable
}
Scrollbar {
id: defaultValuesScrollbar
flickableItem: defaultValuesFlickable
}
//Items used for values sanity checks
Flickable {
id: flickableSanityCheck
width: units.gu(30)
height: units.gu(40)
Rectangle {
id: contentSanityCheck
width: units.gu(20)
height: units.gu(30)
color: "yellow"
}
}
Scrollbar {
id: scrollbarSanityCheck
flickableItem: flickableSanityCheck
}
}
}
ScrollbarTestCase {
name: "Scrollbar"
function getFreshFlickable(alignment) {
var wrapper = createTemporaryObject(flickableComp, column, { scrollbarAlignment: alignment } )
verify(wrapper !== null, "Error: dynamic item creation failed.")
compare(wrapper.scrollbar.align, alignment, "getFreshFlickable: wrong alignment.")
return wrapper
}
function init_data() {
return [
{ tag: "vertical scrollbar", alignment: Qt.AlignTrailing },
{ tag: "horizontal scrollbar", alignment: Qt.AlignBottom }
]
}
function clickOnStepperAndCheckNoContentPositionChange(msgPrefix, itemToClickOn, flickable, expectedContentX, expectedContentY) {
clickInTheMiddle(itemToClickOn)
wait(150)
checkNoContentPositionChange(msgPrefix, flickable, expectedContentX, expectedContentY)
}
//NOTE: this does not test that the properties have the correct value, just that
//their values is not out of range (so it only applies to numeric values or enums)
function performStyleSanityCheck(scrollbar) {
var style = scrollbar.__styleInstance
/*****************************************************
* STYLING PROPERTIES *
*****************************************************/
verify(style.minimumSliderSize >= 0, "Sanity check: invalid property value.")
verify(style.overlayOpacityWhenShown > 0, "Sanity check: invalid property value.")
verify(style.overlayOpacityWhenHidden >= 0, "Sanity check: invalid property value.")
verify(style.troughThicknessSteppersStyle > 0, "Sanity check: invalid property value.")
verify(style.troughThicknessThumbStyle > 0, "Sanity check: invalid property value.")
verify(style.troughThicknessIndicatorStyle > 0, "Sanity check: invalid property value.")
verify(style.sliderRadius >= 0, "Sanity check: invalid property value.")
verify(style.thumbThickness > 0, "Sanity check: invalid property value.")
verify(style.indicatorThickness > 0, "Sanity check: invalid property value.")
verify(style.scrollbarThicknessAnimation.duration >= 0, "Sanity check: invalid property value.")
verify(style.scrollbarFadeInAnimation.duration >= 0, "Sanity check: invalid property value.")
verify(style.scrollbarFadeOutAnimation.duration >= 0, "Sanity check: invalid property value.")
verify(style.scrollbarFadeOutPause >= 0, "Sanity check: invalid property value.")
verify(style.scrollbarCollapsePause >= 0, "Sanity check: invalid property value.")
verify(style.shortScrollingRatio > 0, "Sanity check: invalid property value.")
verify(style.longScrollingRatio > 0, "Sanity check: invalid property value.")
verify(style.hintingStyle === 'thumb'
|| style.hintingStyle === 'indicator', "Sanity check: invalid property value.")
verify(style.thumbsExtremesMargin >= 0, "Sanity check: invalid property value.")
/*****************************************************
* HELPER PROPERTIES *
*****************************************************/
verify(!!style.thumb, "Sanity check: invalid property value.")
verify(!!style.trough, "Sanity check: invalid property value.")
//flickable helper properties
verify(!!style.flickableItem, "Sanity check: invalid property value.")
/*****************************************************
* INTERNAL PROPERTIES AND FUNCTIONS *
*****************************************************/
verify(style.nonOverlayScrollbarMargin >= 0, "Sanity check: invalid property value.")
verify(style.touchDragStartMargin >= 0, "Sanity check: invalid property value.")
verify(style.dragThreshold >= 0, "Sanity check: invalid property value.")
verify(style.__stepperAssetWidth <= style.troughThicknessSteppersStyle, "Sanity check: check that the stepper arrow is narrower than the trough.")
verify(style.__stepperImgOpacityNormal < style.__stepperImgOpacityOnHover, "Sanity check: check that stepper is darker on hover than on normal state.")
verify(style.__stepperImgOpacityOnHover < style.__stepperImgOpacityOnPressed, "Sanity check: check that stepper is darker on pressed than on hover state.")
verify(style.__stepperBgOpacityOnHover < style.__stepperBgOpacityOnPressed, "Sanity check: check that stepper background is darker on pressed than on hover state.")
}
function test_visibility(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var scrollbar = freshTestItem.scrollbar
compare(scrollbar.visible, true, "Wrong Scrollbar visible property value")
scrollbar.flickableItem = null
compare(scrollbar.visible, false, "Wrong Scrollbar visible property value")
//check that the same apply to a scrollbar that was born without Flickable
var nullFlickableScrollbar = freshScrollbar.createObject(freshTestItem)
verify(nullFlickableScrollbar !== null, "Error: dynamic item creation failed.")
compare(nullFlickableScrollbar.visible, false, "Scrollbar is visible before an initialized flickable is assigned to it")
nullFlickableScrollbar.destroy()
}
//no need to test the anchors values when flickable is not set because we already
//test that the scrollbar is hidden when there's no flickable set
function test_bottomAlign_anchors() {
compare(scrollbar_bottomAlign_anchors.flickableItem,
flickable_bottomAlign_anchors, "wrong flickableItem")
compare(scrollbar_bottomAlign_anchors.anchors.left,
scrollbar_bottomAlign_anchors.flickableItem.left, "left anchor")
compare(scrollbar_bottomAlign_anchors.anchors.right,
scrollbar_bottomAlign_anchors.flickableItem.right, "right anchor")
compare(scrollbar_bottomAlign_anchors.anchors.bottom,
scrollbar_bottomAlign_anchors.flickableItem.bottom, "bottom anchor")
//we can't check that the top anchor is not anchored
}
function test_topAlign_anchors() {
compare(scrollbar_topAlign_anchors.flickableItem,
flickable_topAlign_anchors, "wrong flickableItem")
compare(scrollbar_topAlign_anchors.anchors.left,
scrollbar_topAlign_anchors.flickableItem.left, "left anchor")
compare(scrollbar_topAlign_anchors.anchors.right,
scrollbar_topAlign_anchors.flickableItem.right, "right anchor")
compare(scrollbar_topAlign_anchors.anchors.top,
scrollbar_topAlign_anchors.flickableItem.top, "top anchor")
}
function test_leadingAlign_anchors() {
compare(scrollbar_leadingAlign_anchors.flickableItem,
flickable_leadingAlign_anchors, "wrong flickableItem")
compare(scrollbar_leadingAlign_anchors.anchors.left,
scrollbar_leadingAlign_anchors.flickableItem.left, "left anchor")
compare(scrollbar_leadingAlign_anchors.anchors.bottom,
scrollbar_leadingAlign_anchors.flickableItem.bottom, "bottom anchor")
compare(scrollbar_leadingAlign_anchors.anchors.top,
scrollbar_leadingAlign_anchors.flickableItem.top, "top anchor")
}
function test_trailingAlign_anchors() {
compare(scrollbar_trailingAlign_anchors.flickableItem,
flickable_trailingAlign_anchors, "wrong flickableItem")
compare(scrollbar_trailingAlign_anchors.anchors.right,
scrollbar_trailingAlign_anchors.flickableItem.right, "right anchor")
compare(scrollbar_trailingAlign_anchors.anchors.bottom,
scrollbar_trailingAlign_anchors.flickableItem.bottom, "bottom anchor")
compare(scrollbar_trailingAlign_anchors.anchors.top,
scrollbar_trailingAlign_anchors.flickableItem.top, "top anchor")
}
function test_indicatorStyleWhileFlicking_shortContent(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
compare(scrollbar.__styleInstance.veryLongContentItem, false, "Scrollable item should be short.")
//The final "1" is a workaround to bug #1549256
flick(flickable, 2, 2, -units.gu(10), -units.gu(10), undefined, undefined, undefined, undefined, 1)
tryCompare(flickable, "moving", true, 5000, "Flickable not moving after simulating a flick.")
compare(scrollbar.__styleInstance.state, "indicator", "Wrong style while flicking.")
//we don't set it up before because the hinting feature already changes the state
setupSignalSpy(anotherSignalSpy, scrollbar.__styleInstance, "stateChanged")
//wait for the flickable to stop
tryCompare(flickable, "moving", false, 5000, "Flickable still moving after timeout.")
anotherSignalSpy.wait()
compare(anotherSignalSpy.count, 1, "State unchanged after Flickable stopped moving.")
compare(scrollbar.__styleInstance.state, "hidden", "Wrong style after the item stopped moving.")
}
function test_thumbStyleWhileFlicking_veryLongContent(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
setupSignalSpy(signalSpy, scrollbar.__styleInstance, "veryLongContentItemChanged")
setVeryLongContentItem(flickable, scrollbar.__styleInstance, false)
signalSpy.wait()
compare(scrollbar.__styleInstance.veryLongContentItem, true, "Very long content item not detected")
//The final "1" is a workaround to bug #1549256
flick(flickable, 2, 2, -units.gu(10), -units.gu(10), undefined, undefined, undefined, undefined, 1)
tryCompare(flickable, "moving", true, 5000, "Flickable not moving after simulating a flick.")
compare(scrollbar.__styleInstance.state, "thumb", "Wrong style while flicking a very long item")
setupSignalSpy(anotherSignalSpy, scrollbar.__styleInstance, "stateChanged")
//wait for the flickable to stop
tryCompare(flickable, "moving", false, 5000, "Flickable still moving after timeout.")
anotherSignalSpy.wait()
compare(anotherSignalSpy.count, 1, "State unchanged after Flickable stopped moving.")
compare(scrollbar.__styleInstance.state, "hidden", "Wrong style after a the item stopped moving.")
}
function test_scrollingWithContentMargins(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var style = freshTestItem.scrollbar.__styleInstance
var scrollbarUtils = getScrollbarUtils(scrollbar)
//to make sure that it's only scrolling in the direction it should
var notScrollingProperty = scrollbarUtils.propContent === "contentX" ? "contentY" : "contentX"
addContentMargins(flickable)
style.scrollToBeginning(false)
compare(flickable[notScrollingProperty], 0, "ContentX changed when it shouldn't")
compare(flickable[scrollbarUtils.propContent],
style.isVertical ? -flickable.topMargin : -flickable.leftMargin,
"Wrong beginning contentY")
style.scrollToEnd(false)
compare(flickable[notScrollingProperty], 0, "ContentX changed when it shouldn't")
compare(flickable[scrollbarUtils.propContent],
style.isVertical
? flickable.contentHeight + flickable.bottomMargin - flickable[scrollbarUtils.propSize]
: flickable.contentWidth + flickable.rightMargin - flickable[scrollbarUtils.propSize],
"Wrong end contentY")
//contentHeight+top+bottom is the max you can scroll anyway, so it's
//safe to use it, and the scrollbar should go to returnToBounds() if it goes beyond
var maxScrolling = style.totalContentSize
style.scrollBy(-maxScrolling, false)
compare(flickable[notScrollingProperty], 0, "ContentX changed when it shouldn't")
compare(flickable[scrollbarUtils.propContent],
style.isVertical ? -flickable.topMargin : -flickable.leftMargin,
"scrollBy: wrong contentY after scrolling to the beginning")
style.scrollBy(maxScrolling, false)
compare(flickable[notScrollingProperty], 0, "ContentX changed when it shouldn't")
compare(flickable[scrollbarUtils.propContent],
style.isVertical
? flickable.contentHeight + flickable.bottomMargin - flickable[scrollbarUtils.propSize]
: flickable.contentWidth + flickable.rightMargin - flickable[scrollbarUtils.propSize],
"scrollBy: wrong contentY after scrolling to the end")
//we can only scroll up now
var oldContentProp = flickable[scrollbarUtils.propContent]
style.scrollBy(-units.gu(1), false)
compare(flickable[scrollbarUtils.propContent],
oldContentProp - units.gu(1),
"scrollBy: wrong contentY after scrolling by +1GU")
style.scrollBy(units.gu(1), false)
compare(flickable[scrollbarUtils.propContent],
oldContentProp,
"scrollBy: wrong contentY after scrolling by -1GU")
}
function test_showSteppers(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var style = scrollbar.__styleInstance
var steppersTransition = findInListProperty(scrollbar.__styleInstance.transitions, "indicatorToThumbSteppersTransition")
verify(steppersTransition !== null, "Could not find transition object")
setupSignalSpy(signalSpy, scrollbar.__styleInstance, "stateChanged")
setupSignalSpy(anotherSignalSpy, steppersTransition, "runningChanged")
//show steppers on mouse move
mouseMove(scrollbar, 0, 0)
signalSpy.wait()
compare(signalSpy.count, 1, "Mouse move doesn't trigger state change")
anotherSignalSpy.wait()
compare(anotherSignalSpy.count, 1, "Mouse move doesn't trigger state transition")
compare(scrollbar.__styleInstance.state, "steppers", "Mouse move doesn't trigger steppers state.")
var firstStepper = getFirstStepper(scrollbar)
var secondStepper = getSecondStepper(scrollbar)
var trough = getTrough(scrollbar)
compare(trough.visible, true, "Trough not visible in steppers state")
compare(firstStepper.visible, true, "First stepper not visible in steppers state")
compare(secondStepper.visible, true, "Second stepper not visible in steppers state")
anotherSignalSpy.wait()
compare(anotherSignalSpy.count, 2, "State transition does not complete.")
compare(steppersTransition.running, false, "State transition does not stop.")
if (style.isVertical) {
compare(trough.width, scrollbar.__styleInstance.troughThicknessSteppersStyle, "Wrong trough thickness in steppers style")
} else {
compare(trough.height, scrollbar.__styleInstance.troughThicknessSteppersStyle, "Wrong trough thickness in steppers style")
}
}
function checkSteppersColour(scrollbar, firstStepperStateString, secondStepperStateString, testDescription) {
var firstStepper = getFirstStepper(scrollbar)
var secondStepper = getSecondStepper(scrollbar)
var firstStepperIcon = getFirstStepperIcon(scrollbar)
var secondStepperIcon = getSecondStepperIcon(scrollbar)
var style = scrollbar.__styleInstance
var stepperBgColorBase = style.stepperBgColor
var stepperImgColor = style.sliderColor
var stepperBgColorDisabled = "transparent"
var stepperImgColorDisabled = Qt.rgba(stepperImgColor.r, stepperImgColor.g, stepperImgColor.b,
stepperImgColor.a * style.__stepperImgOpacityDisabled)
var stepperBgColorNormal = "transparent"
var stepperImgColorNormal = Qt.rgba(stepperImgColor.r, stepperImgColor.g, stepperImgColor.b,
stepperImgColor.a * style.__stepperImgOpacityNormal)
var stepperBgColorOnHover = Qt.rgba(stepperBgColorBase.r, stepperBgColorBase.g, stepperBgColorBase.b,
stepperBgColorBase.a * style.__stepperBgOpacityOnHover)
var stepperImgColorOnHover = Qt.rgba(stepperImgColor.r, stepperImgColor.g, stepperImgColor.b,
stepperImgColor.a * style.__stepperImgOpacityOnHover)
var stepperBgColorOnPressed = Qt.rgba(stepperBgColorBase.r, stepperBgColorBase.g, stepperBgColorBase.b,
stepperBgColorBase.a * style.__stepperBgOpacityOnPressed)
var stepperImgColorOnPressed = Qt.rgba(stepperImgColor.r, stepperImgColor.g, stepperImgColor.b,
stepperImgColor.a * style.__stepperImgOpacityOnPressed)
switch (firstStepperStateString) {
case "disabled":
var expectedFirstStepperColour = stepperBgColorDisabled
var expectedFirstStepperIconColour = stepperImgColorDisabled
break
case "normal":
var expectedFirstStepperColour = stepperBgColorNormal
var expectedFirstStepperIconColour = stepperImgColorNormal
break
case "hovered":
var expectedFirstStepperColour = stepperBgColorOnHover
var expectedFirstStepperIconColour = stepperImgColorOnHover
break
case "pressed":
var expectedFirstStepperColour = stepperBgColorOnPressed
var expectedFirstStepperIconColour = stepperImgColorOnPressed
break
default:
fail("Invalid stepper state string")
}
switch (secondStepperStateString) {
case "disabled":
var expectedSecondStepperColour = stepperBgColorDisabled
var expectedSecondStepperIconColour = stepperImgColorDisabled
break
case "normal":
var expectedSecondStepperColour = stepperBgColorNormal
var expectedSecondStepperIconColour = stepperImgColorNormal
break
case "hovered":
var expectedSecondStepperColour = stepperBgColorOnHover
var expectedSecondStepperIconColour = stepperImgColorOnHover
break
case "pressed":
var expectedSecondStepperColour = stepperBgColorOnPressed
var expectedSecondStepperIconColour = stepperImgColorOnPressed
break
default:
fail("Invalid stepper state string")
}
var msg = "First stepper expected state: " + firstStepperStateString + "."
+ " Second stepper expected state: " + secondStepperStateString + ". "
+ " Test description: " + testDescription + ". "
+ " Error encountered: "
//compare() returns pass on different colours, see https://bugreports.qt.io/browse/QTBUG-34878
compare(Qt.colorEqual(firstStepper.color, expectedFirstStepperColour), true,
msg + "wrong first stepper background color.")
compare(Qt.colorEqual(firstStepperIcon.color, expectedFirstStepperIconColour), true,
msg + "wrong first stepper icon color.")
compare(Qt.colorEqual(secondStepper.color, expectedSecondStepperColour), true,
msg + "wrong second stepper background color.")
compare(Qt.colorEqual(secondStepperIcon.color, expectedSecondStepperIconColour), true,
msg + "wrong second stepper icon color.")
}
function test_checkStepperStatesStyling(data) {
skip("Scrollbar already in steppers mode under Qt 5.9, causing failure.")
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var style = scrollbar.__styleInstance
var firstStepper = getFirstStepper(scrollbar)
var secondStepper = getSecondStepper(scrollbar)
triggerSteppersMode(scrollbar)
//the following tests are assuming that the steppers are not disabled
compare(style.isScrollable, true, "Scrollbar is not scrollable, cannot test steppers hover/pressed state.")
if (style.isVertical) {
compare(style.flickableItem.atYBeginning, true, "View not scrolled to the beginning as expected.")
compare(style.flickableItem.atYEnd, false, "View unexpectedly already scrolled to the end.")
} else {
compare(style.flickableItem.atXBeginning, true, "View not scrolled to the beginning as expected.")
compare(style.flickableItem.atXEnd, false, "View unexpectedly already scrolled to the end.")
}
//Check that the first stepper is disabled and the second one is in normal state
checkSteppersColour(scrollbar, "disabled", "normal", "default state before moving mouse")
//Check that hovering on a disabled stepper does not change its colour
mouseMove(firstStepper, firstStepper.width/2, firstStepper.height/2)
checkSteppersColour(scrollbar, "disabled", "normal", "mouse hovered to disabled first stepper")
//Check that tapping on a disabled stepper does not change its colour
mousePress(firstStepper, firstStepper.width/2, firstStepper.height/2)
checkSteppersColour(scrollbar, "disabled", "normal", "mouse pressed on disabled first stepper")
mouseRelease(firstStepper, firstStepper.width/2, firstStepper.height/2)
//move mouse away from the steppers
mouseMove(scrollbar, 0, 0)
//Scroll to the bottom to check disabled state of the second stepper
var thumb = getThumb(scrollbar)
var trough = getTrough(scrollbar)
if (style.isVertical) {
mouseMove(thumb, 0, 0)
mouseDrag(thumb, thumb.width/2, thumb.height/2, 0, trough.height)
compare(style.flickableItem.atYBeginning, false, "View not scrolled to the bottom as expected.")
compare(style.flickableItem.atYEnd, true, "View unexpectedly at the beginning.")
} else {
mouseMove(thumb, 0, 0)
mouseDrag(thumb, thumb.width/2, thumb.height/2, trough.width, 0)
compare(style.flickableItem.atXBeginning, false, "View not scrolled to the bottom as expected.")
compare(style.flickableItem.atXEnd, true, "View unexpectedly at the beginning.")
}
//Check that the first stepper is normal and the second one is in disable state
checkSteppersColour(scrollbar, "normal", "disabled", "after thumb dragged to bottom and mouse moved away from steppers.")
//Check that hovering on a disabled stepper does not change its colour
mouseMove(secondStepper, secondStepper.width/2, secondStepper.height/2)
checkSteppersColour(scrollbar, "normal", "disabled", "thumb at the bottom, mouse hovered on disabled second stepper")
//Check that tapping on a disabled stepper does not change its colour
mousePress(secondStepper, secondStepper.width/2, secondStepper.height/2)
checkSteppersColour(scrollbar, "normal", "disabled", "thumb at the bottom, mouse pressed on disabled second stepper")
mouseRelease(secondStepper, secondStepper.width/2, secondStepper.height/2)
//move mouse away from the steppers
mouseMove(scrollbar, 0, 0)
//trigger first stepper to scroll up a bit, so that they're both not disabled
//scrolling up with a stepper should not scroll to the top, unless there's a bug somewhere else
//or the flickable test item gets changed
clickInTheMiddle(firstStepper)
checkScrolling(flickable, style.flickableItem.contentX, style.flickableItem.contentY, style,
false, -1, "First stepper, click")
//the previous click ungrabs the mouse after release, so we can't directly send a Move outside
//the stepper's area because QQuickWindow will just deliver it to the item at that coord, given
//that there is no item grabbing the mouse. So we have to send a mouse move
//to the second stepper INSIDE its area, before we can send it an event outside
//its area in order to trigger HoverLeave.
mouseMove(secondStepper, 0, 0)
//send an event outside the area of the second stepper (read comment above). This will
//trigger HoverLeave for the secondStepper. If you want to know why, see
//https://github.com/qtproject/qtdeclarative/blob/5.4/src/quick/items/qquickwindow.cpp#L1666
mouseMove(scrollbar, 0, 0)
//Check colours in normal state
checkSteppersColour(scrollbar, "normal", "normal", "mouse moved away from steppers")
//Hover on first stepper and check colour of both steppers
mouseMove(firstStepper, firstStepper.width/2, firstStepper.height/2)
checkSteppersColour(scrollbar, "hovered", "normal", "mouse hovered on first stepper")
//Press on first stepper and check colour of both steppers
mousePress(firstStepper, firstStepper.width/2, firstStepper.height/2)
checkSteppersColour(scrollbar, "pressed", "normal", "mouse pressed on first stepper")
mouseRelease(firstStepper, firstStepper.width/2, firstStepper.height/2)
//Hover on second stepper and check colour of both steppers
mouseMove(secondStepper, secondStepper.width/2, secondStepper.height/2)
checkSteppersColour(scrollbar, "normal", "hovered", "mouse hovered on second stepper")
//Press on second stepper and check colour of both steppers
mousePress(secondStepper, secondStepper.width/2, secondStepper.height/2)
checkSteppersColour(scrollbar, "normal", "pressed", "mouse pressed on second stepper")
mouseRelease(secondStepper, secondStepper.width/2, secondStepper.height/2)
//Check that pressing on a stepper (mouse-only) will activate the hover state
//even without a mouse move (i.e. without onEntered/onExited, which can often
//happen in unit tests)
//Press on first stepper without first firing mouseMove and check colour of both steppers
mousePress(firstStepper, firstStepper.width/2, firstStepper.height/2)
checkSteppersColour(scrollbar, "pressed", "normal", "mouse pressed on first stepper without sending mouseMove before")
mouseRelease(firstStepper, firstStepper.width/2, firstStepper.height/2)
checkSteppersColour(scrollbar, "hovered", "normal", "after mouse released while on first stepper")
//Press on second stepper without first firing mouseMove and check colour of both steppers
mousePress(secondStepper, secondStepper.width/2, secondStepper.height/2)
checkSteppersColour(scrollbar, "normal", "pressed", "mouse pressed on second stepper without sending mouseMove before")
mouseRelease(secondStepper, secondStepper.width/2, secondStepper.height/2)
checkSteppersColour(scrollbar, "normal", "hovered", "after mouse released while on second stepper")
}
//test that moving the mouse inside and outside any of the hover area borders has the expected effect
function test_thumbHoverArea(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var thumb = getThumb(scrollbar)
var thumbArea = getThumbArea(scrollbar)
var trough = getTrough(scrollbar)
var style = freshTestItem.scrollbar.__styleInstance
var scrollbarUtils = getScrollbarUtils(scrollbar)
var secondStepper = getSecondStepper(scrollbar)
var thumbNormalColor = Qt.rgba(style.sliderColor.r, style.sliderColor.g, style.sliderColor.b,
style.sliderColor.a * 0.4)
var thumbHoveredColor = Qt.rgba(style.sliderColor.r, style.sliderColor.g, style.sliderColor.b,
style.sliderColor.a * 0.7)
var thumbPressedColor = Qt.rgba(style.sliderColor.r, style.sliderColor.g, style.sliderColor.b,
style.sliderColor.a * 1.0)
addContentMargins(flickable)
setContentPositionToTopLeft(flickable)
triggerSteppersMode(scrollbar)
//check colour of the thumb in normal state
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true, "Wrong thumb color in normal state.")
//hover on the middle
mouseMove(thumb, thumb.width/2, thumb.height/2)
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true, "Wrong thumb color in hover state.")
//check that moving mouse outside the thumb (to the second stepper, in this case) and back in will
//trigger the correct color changes
mouseMove(secondStepper, secondStepper.width/2, secondStepper.height/2)
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true, "Wrong thumb color after moving mouse to a stepper.")
mouseMove(thumb, thumb.width/2, thumb.height/2)
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true,
"Wrong thumb color after moving mouse from stepper back into the thumb.")
//check pressed state colour
mousePress(thumb, thumb.width/2, thumb.height/2)
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true, "Wrong thumb color in pressed state.")
mouseRelease(thumb, thumb.width/2, thumb.height/2)
//check hovered colour again, the thumb should still show as hovered after releasing mouse
//(assuming the mouse is still inside it, which it is)
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true,
"Thumb does not show as hovered after mouse press-release inside it.")
//depending on how the implementation of the scrollbar evolves, the input area
//may become bigger than the trough on one or both sides, so we map the coords
//to know where to send events relative to the thumb so that they hit the trough
//(which is part of the hover area, along the scrolling axis, i.e. x-axis for vert.scrollbar)
var mappedCoords = thumb.mapToItem(trough, 0, 0)
//mouseMove seem to deliver events at pixel bound, so we have to take the floor of the sizes
//otherwise if thumb has width 50.6, mouseMove(thumb, 50.6, 0) will send an event to x==51 and that
//will cause the logic to assume the mouse is outside the hover area while it's on the border
var floorThumbWidth = Math.floor(thumb.width)
var floorThumbHeight = Math.floor(thumb.height)
var floorTroughWidth = Math.floor(trough.width)
var floorTroughHeight = Math.floor(trough.height)
//top-left and bottom-right coords of the rectangle defining the thumb hover area
//we need different handling of vertical/horizontal because the hover area is defined
//as the whole trough along the scrolling axis (e.g. whole trough width for the vert. scrollbar)
//and exactly the thumb along the non-scrolling axis (e.g. thumb's height for vert. scrollbar
if (style.isVertical) {
var insideTopLeft = [-mappedCoords.x , 0 ]
var insideBottomRight = [-mappedCoords.x + floorTroughWidth - 1, floorThumbHeight]
} else {
var insideTopLeft = [0 , -mappedCoords.y ]
var insideBottomRight = [floorThumbWidth, -mappedCoords.y + floorTroughHeight - 1]
}
mouseMove(thumb, insideTopLeft[0], insideTopLeft[1])
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true,
"Thumb does not show as hovered after mouse moved to the top-left corner of the hover area.")
mouseMove(thumb, insideBottomRight[0], insideBottomRight[1])
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true,
"Thumb does not show as hovered after mouse moved to the bottom-right corner of the hover area.")
//right outside the hover area
var outsideTopBorder = [insideTopLeft[0] , insideTopLeft[1] - 1] //move 1 up
var outsideLeftBorder = [insideTopLeft[0] - 1 , insideTopLeft[1]] //move 1 left
var outsideBottomBorder = [insideBottomRight[0] , insideBottomRight[1] + 1] //move 1 down
var outsideRightBorder = [insideBottomRight[0] + 1 , insideBottomRight[1]] //move 1 right
//check that when the mouse is right outside the borders of the hover area the thumb will use the non-hover colour
mouseMove(thumb, outsideTopBorder[0], outsideTopBorder[1])
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true,
"Thumb does not show as NOT-hovered after mouse moved outside the top border of the hover area.")
mouseMove(thumb, outsideBottomBorder[0], outsideBottomBorder[1])
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true,
"Thumb does not show as NOT-hovered after mouse moved outside the bottom border of the hover area.")
mouseMove(thumb, outsideLeftBorder[0], outsideLeftBorder[1])
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true,
"Thumb does not show as NOT-hovered after mouse moved outside the left border of the hover area.")
mouseMove(thumb, outsideRightBorder[0], outsideRightBorder[1])
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true,
"Thumb does not show as NOT-hovered after mouse moved outside the right border of the hover area.")
//BUG #1616926
//check pressind on the THUMB and releasing mouse outside the TROUGH resets it to normal state
//press thumb, move mouse outside the trough and check that the thumb is not showing as hovered
//The broken logic was just checking if mouse was inside the thumb
//on the same axis as the scrolling one (so y for vertical scrollbar, x for horizontal) so we move
//mouse in the opposite axis (i.e. along x if vertical scrollbar) to check that the bug is fixed
mousePress(thumb, thumb.width/2, thumb.height/2)
if (style.isVertical) {
mouseMove(thumb, outsideLeftBorder[0], outsideLeftBorder[1])
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true, "Wrong THUMB color in pressed state.")
mouseRelease(thumb, outsideLeftBorder[0], outsideLeftBorder[1])
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true, "Wrong THUMB color after releasing mouse with x outside TROUGH.")
} else {
mouseMove(thumb, outsideTopBorder[0], outsideTopBorder[1])
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true, "Wrong THUMB color in pressed state.")
mouseRelease(thumb, outsideTopBorder[0], outsideTopBorder[1])
compare(Qt.colorEqual(thumb.color, thumbNormalColor), true, "Wrong THUMB color after releasing mouse with y outside TROUGH.")
}
}
//test dragging the thumb and relative visual changes due to hover/pressed states
function test_dragThumbAndCheckStyling(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var thumb = getThumb(scrollbar)
var thumbArea = getThumbArea(scrollbar)
var trough = getTrough(scrollbar)
var style = freshTestItem.scrollbar.__styleInstance
var scrollbarUtils = getScrollbarUtils(scrollbar)
var secondStepper = getSecondStepper(scrollbar)
var thumbNormalColor = Qt.rgba(style.sliderColor.r, style.sliderColor.g, style.sliderColor.b,
style.sliderColor.a * 0.4)
var thumbHoveredColor = Qt.rgba(style.sliderColor.r, style.sliderColor.g, style.sliderColor.b,
style.sliderColor.a * 0.7)
var thumbPressedColor = Qt.rgba(style.sliderColor.r, style.sliderColor.g, style.sliderColor.b,
style.sliderColor.a * 1.0)
addContentMargins(flickable)
setContentPositionToTopLeft(flickable)
triggerSteppersMode(scrollbar)
if (style.isVertical) {
mouseDrag(thumb, thumb.width/2, thumb.height/2, 0, trough.height)
compare(flickable[scrollbarUtils.propContent],
flickable.contentHeight + flickable.bottomMargin - flickable.height,
"Vertical thumb mouse drag: wrong contentProp after dragging to the end")
var sceneThumbY = thumb.mapToItem(column, 0, 0).y
//Cannot use mouseDrag here, because the thumb is at the end of the trough.
//mouseDrag uses
//mouseMove(item, x + util.dragThreshold + 1, y + util.dragThreshold + 1, delay, button)
//to trigger the drag, but in our case that cannot work because the scrollbar is at
//the end of the trough, hence cannot move to its
//bottom (vertical scrollbar) or to its right (in the case of the horiz scrollbar)
mousePress(thumb, thumb.width/2, thumb.height/2)
mouseMove(thumb, thumb.width/2, 0 )
//drag to the beginning
mouseMove(thumb, thumb.width/2, -sceneThumbY)
//try moving the mouse outside the thumb (to the left, the 10* is random)
//and check that it's still using the pressed state colour
mouseMove(thumb, -10*thumb.width/2, -sceneThumbY)
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true,
"Not showing pressed colour after dragging the thumb up and moving mouse outside of it without releasing.")
//move mouse back inside the thumb
mouseMove(thumb, thumb.width/2, -sceneThumbY)
//check pressed colour again
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true,
"Not showing pressed colour after dragging the thumb up and moving mouse outside of it and back in, without releasing.")
mouseRelease(thumb, 0, 0)
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true,
"Thumb does not show as hovered after mouse is dragged and released inside of it.")
compare(flickable[scrollbarUtils.propContent], -flickable.topMargin,
"Vertical thumb mouse drag: wrong contentProp after dragging to the beginning")
} else {
mouseDrag(thumb, thumb.width/2, thumb.height/2, trough.width, 0)
compare(flickable[scrollbarUtils.propContent],
flickable.contentWidth + flickable.rightMargin - flickable.width,
"Horizontal thumb mouse drag: wrong contentProp after dragging to the end")
var sceneThumbX = thumb.mapToItem(column, 0, 0).x
//Can't use mouseDrag here, see the explanation inside the "if" branch
mousePress(thumb, thumb.width/2, thumb.height/2)
mouseMove(thumb, 0, thumb.height/2 )
//drag to beginning
mouseMove(thumb, -sceneThumbX, thumb.height/2)
//try moving the mouse outside the thumb (to the top, the 10* is random)
//and check that it's still using the pressed state colour
mouseMove(thumb, -sceneThumbX, -10*thumb.height/2)
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true,
"Not showing pressed colour after dragging the thumb up and moving mouse outside of it without releasing.")
//move mouse back inside the thumb
mouseMove(thumb, -sceneThumbX, thumb.height/2)
//check pressed colour again
compare(Qt.colorEqual(thumb.color, thumbPressedColor), true,
"Not showing pressed colour after dragging the thumb up and moving mouse outside of it and back in, without releasing.")
mouseRelease(thumb, 0, 0)
compare(Qt.colorEqual(thumb.color, thumbHoveredColor), true,
"Thumb does not show as hovered after mouse is dragged and released inside of it.")
compare(flickable[scrollbarUtils.propContent], -flickable.leftMargin,
"Horizontal thumb mouse drag: wrong contentProp after dragging to the beginning")
}
}
function test_hinting_data() {
return [
//ownSide here is the side the scrollable cares about, i.e. height for vert scrollbar
{tag: "vertical scrollbar, no scrollable side, short content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: false, scrollableVertically: false, veryLong: false },
{tag: "horizontal scrollbar, no scrollable side, short content item",
alignment: Qt.AlignBottom, scrollableHorizontally: false, scrollableVertically: false, veryLong: false },
{tag: "vertical scrollbar, horizontal side scrollable, short content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: true, scrollableVertically: false, veryLong: false },
{tag: "horizontal scrollbar, horizontal side scrollable, short content item",
alignment: Qt.AlignBottom, scrollableHorizontally: true, scrollableVertically: false, veryLong: false },
{tag: "vertical scrollbar, vertical side scrollable, short content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: false, scrollableVertically: true, veryLong: false },
{tag: "horizontal scrollbar, vertical side scrollable, short content item",
alignment: Qt.AlignBottom, scrollableHorizontally: false, scrollableVertically: true, veryLong: false },
{tag: "vertical scrollbar, both sides scrollable, short content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: true, scrollableVertically: true, veryLong: false },
{tag: "horizontal scrollbar, both sides scrollable, short content item",
alignment: Qt.AlignBottom, scrollableHorizontally: true, scrollableVertically: true, veryLong: false },
{tag: "vertical scrollbar, no scrollable side, long content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: false, scrollableVertically: false, veryLong: true },
{tag: "horizontal scrollbar, no scrollable side, long content item",
alignment: Qt.AlignBottom, scrollableHorizontally: false, scrollableVertically: false, veryLong: true },
{tag: "vertical scrollbar, horizontal side scrollable, long content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: true, scrollableVertically: false, veryLong: true },
{tag: "horizontal scrollbar, horizontal side scrollable, long content item",
alignment: Qt.AlignBottom, scrollableHorizontally: true, scrollableVertically: false, veryLong: true },
{tag: "vertical scrollbar, vertical side scrollable, long content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: false, scrollableVertically: true, veryLong: true },
{tag: "horizontal scrollbar, vertical side scrollable, long content item",
alignment: Qt.AlignBottom, scrollableHorizontally: false, scrollableVertically: true, veryLong: true },
{tag: "vertical scrollbar, both sides scrollable, long content item",
alignment: Qt.AlignTrailing, scrollableHorizontally: true, scrollableVertically: true, veryLong: true },
{tag: "horizontal scrollbar, both sides scrollable, long content item",
alignment: Qt.AlignBottom, scrollableHorizontally: true, scrollableVertically: true, veryLong: true },
];
}
//test that the scrollbar is shown on contentHeight/width changes
function test_hinting(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var style = freshTestItem.scrollbar.__styleInstance
//we'll add it 1gu to simulate a change that doesn't make it become scrollable
//so we need to make sure adding 1gu doesn't make it scrollable
verify(flickable.width > units.gu(5), "Flickable width assumption is satisfied.")
verify(flickable.height > units.gu(5), "Flickable height assumption is satisfied.")
flickable.contentWidth = units.gu(2)
flickable.contentHeight = units.gu(2)
checkNonScrollableState(scrollbar)
if (data.scrollableHorizontally) {
if (data.veryLong) {
setVeryLongContentItem(flickable, style, true)
tryCompare(style, "veryLongContentItem", true, 5000, "Hinting: veryLongContentItem should be true.")
} else {
flickable.contentWidth = flickable.width + units.gu(1)
}
if (!style.isVertical) {
checkHinting(scrollbar)
//wait for the hinting to finish
checkScrollableAndHidden(scrollbar)
} else {
//make sure the scrollbar was not affected by the size change of the opposite side
checkNonScrollableState(scrollbar)
}
}
if (data.scrollableVertically) {
if (data.veryLong) {
setVeryLongContentItem(flickable, style, false)
tryCompare(style, "veryLongContentItem", true, 5000, "Hinting: veryLongContentItem should be true.")
} else {
flickable.contentHeight = flickable.height + units.gu(1)
}
if (style.isVertical) {
checkHinting(scrollbar)
checkScrollableAndHidden(scrollbar)
} else {
//Only make sure that the horiz scrollbar is not scrollable IF
//we didn't previously also make the horizontal side scrollable
if (!data.scrollableHorizontally) {
checkNonScrollableState(scrollbar)
}
}
}
//try changing contentHeight
flickable.contentHeight += units.gu(1)
if (style.isVertical && data.scrollableVertically) {
checkHinting(scrollbar)
checkScrollableAndHidden(scrollbar)
} else if (!style.isVertical && data.scrollableHorizontally) {
compare(style.state, "hidden", "Wrong state.")
} else {
checkNonScrollableState(scrollbar)
}
flickable.contentWidth += units.gu(1)
if (!style.isVertical && data.scrollableHorizontally) {
checkHinting(scrollbar)
checkScrollableAndHidden(scrollbar)
} else if (style.isVertical && data.scrollableVertically) {
compare(style.state, "hidden", "Wrong state.")
} else {
checkNonScrollableState(scrollbar)
}
}
function test_minimumSliderSize(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var trough = getTrough(scrollbar)
var thumb = getThumb(scrollbar)
var style = freshTestItem.scrollbar.__styleInstance
var minSize = style.minimumSliderSize
verify(trough !== null, "Could not find the trough.")
verify(thumb !== null, "Could not find the thumb.")
if (style.isVertical) {
//ignore margins etc, just go for an upper bound
flickable.contentHeight = flickable.height * (flickable.height / minSize) + units.gu(100)
compare(thumb.height, minSize, "Thumb does not respect the minimum size.")
} else {
flickable.contentWidth = flickable.width * (flickable.width / minSize) + units.gu(100)
compare(thumb.width, minSize, "Thumb does not respect the minimum size.")
}
}
function test_scrollingRatioValuesSanityCheck() {
var freshTestItem = getFreshFlickable(Qt.AlignTrailing)
var style = freshTestItem.scrollbar.__styleInstance
verify(style.shortScrollingRatio > 0,
"Short scrolling ratio must be > 0.")
verify(style.longScrollingRatio > 0,
"Short scrolling ratio must be > 0.")
verify(style.shortScrollingRatio <= style.longScrollingRatio,
"Short scrolling ratio is higher than long scrolling ratio.")
}
// NOTE: ANY FAILURE COMING AFTER MOUSEPRESS WILL LEAVE THE MOUSE IN A DIRTY STATE!
// (QQuickWindow's mouseGrabberItem is not reset)
// OTHER TESTS WILL FAIL JUST BECAUSE THIS TEST HAS NOT CALLED MOUSERELEASE!
// I REPORTED https://bugreports.qt.io/browse/QTBUG-51193 TO GET THIS FIXED
function test_resetDragWhenMouseIsVeryFarFromTheThumb(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var thumb = getThumb(scrollbar)
var style = freshTestItem.scrollbar.__styleInstance
//SKIP THE TEST IF THE FEATURE IS DISABLED
verify(style.__disableDragResetFeature !== undefined, "Check that __disableDragResetFeature exists. Remember to enable this test again when the feature is added back.")
if (style.__disableDragResetFeature) return
compare(style.isScrollable, true, "Item is assumed to be scrollable.")
triggerSteppersMode(scrollbar)
var contentXBackup = flickable.contentX
var contentYBackup = flickable.contentY
//coords of the 2 mouse move used to simulate a drag
var firstStep = units.gu(5)
var secondStep = units.gu(10)
var releaseCoord = units.gu(11)
mousePress(thumb, 0, 0)
mouseMove(thumb,
(style.isVertical ? 0 : firstStep),
(style.isVertical ? firstStep : 0))
mouseMove(thumb,
(style.isVertical ? 0 : secondStep),
(style.isVertical ? secondStep : 0))
var newContentX = flickable.contentX
var newContentY = flickable.contentY
if (style.isVertical) {
verify(newContentY !== contentYBackup, "Check that mouse drag changed contentY." )
} else {
verify(newContentX !== contentXBackup, "Check that mouse drag changed contentX." )
}
mouseMove(thumb,
(style.isVertical ? dragResetThreshold(scrollbar)+1 : secondStep),
(style.isVertical ? secondStep : dragResetThreshold(scrollbar)+1))
//check that it goes back to the pre-drag content position, as if the drag never started
checkNoContentPositionChange("Mouse drag reset", flickable, contentXBackup, contentYBackup)
//go back to the old position
mouseMove(thumb,
(style.isVertical ? 0 : secondStep),
(style.isVertical ? secondStep : 0))
//resume the drag by moving at least 1 px (scrollbar should have 0 drag threshold)
mouseMove(thumb,
(style.isVertical ? 0 : secondStep + style.dragThreshold + 1),
(style.isVertical ? secondStep + style.dragThreshold + 1 : 0))
//NOTE: now the thumb has moved, adding another mouseMove here will use
//coordinates relative to the NEW position!
mouseMove(thumb,
(style.isVertical ? 0 : -(style.dragThreshold + 1)),
(style.isVertical ? -(style.dragThreshold + 1) : 0))
//check that it goes back to the pre-drag content position, as if the drag never started
checkNoContentPositionChange("Mouse drag reset", flickable, contentXBackup, contentYBackup)
//test that we resume dragging
if (style.isVertical) {
verify(newContentY !== contentYBackup, "Check that mouse drag changed contentY." )
} else {
verify(newContentX !== contentXBackup, "Check that mouse drag changed contentX." )
}
//try moving the other way
//FIXME: I'M USING +7 BECAUSE THE LOGIC USES (mouse.x - thumbArea.x)
//AND HERE WE START AT 5px AND THEN MOVE BY 10x + 1
//THE LOGIC HAS TO USE A DIFFERENT CONDITION
mouseMove(thumb,
(style.isVertical ? -(dragResetThreshold(scrollbar) + 7) : secondStep),
(style.isVertical ? secondStep : -(dragResetThreshold(scrollbar) + 7)))
//check that it goes back to the pre-drag content position, as if the drag never started
checkNoContentPositionChange("Mouse drag reset", flickable, contentXBackup, contentYBackup)
mouseRelease(thumb,
(style.isVertical ? -(dragResetThreshold(scrollbar) + 7) : secondStep),
(style.isVertical ? secondStep : -(dragResetThreshold(scrollbar) + 7)))
}
function test_actionSteppers_data() {
return [
{tag:"Content item with margins and vertical scrollbar", addContentMargins: true, alignment: Qt.AlignTrailing},
{tag:"Content item and vertical scrollbar", addContentMargins: false, alignment: Qt.AlignTrailing},
{tag:"Content item with margins and horizontal scrollbar", addContentMargins: true, alignment: Qt.AlignBottom},
{tag:"Content item and horizontal scrollbar", addContentMargins: false, alignment: Qt.AlignBottom}
];
}
function test_actionSteppers(data) {
skip("Scrollbar already in steppers mode under Qt 5.9, causing failure.")
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
var trough = getTrough(scrollbar)
var thumb = getThumb(scrollbar)
var firstStepper = getFirstStepper(scrollbar)
var secondStepper = getSecondStepper(scrollbar)
var style = freshTestItem.scrollbar.__styleInstance
var minSize = style.minimumSliderSize
if (data.addContentMargins) {
addContentMargins(flickable)
}
triggerSteppersMode(scrollbar)
setContentPositionToTopLeft(flickable)
var contentXBackup = flickable.contentX
var contentYBackup = flickable.contentY
clickOnStepperAndCheckNoContentPositionChange("First stepper", firstStepper, flickable,
contentXBackup, contentYBackup)
//NOTE: mouseClick(secondStepper, 0, 0) would trigger firstStepper, because
//the logic uses contains(point) that also counts the edges!
//(the code uses if firstStepper.contains else if secondStepper.contains
//so it stops at the first branch)
clickInTheMiddle(secondStepper)
checkScrolling(flickable, contentXBackup, contentYBackup, style,
false, 1, "Second stepper, first click")
contentXBackup = flickable.contentX
contentYBackup = flickable.contentY
//do it once more
clickInTheMiddle(secondStepper)
checkScrolling(flickable, contentXBackup, contentYBackup, style,
false, 1, "Second stepper, second click")
setContentPositionToBottomRight(flickable)
contentXBackup = flickable.contentX
contentYBackup = flickable.contentY
clickOnStepperAndCheckNoContentPositionChange("Second stepper", secondStepper, flickable,
contentXBackup, contentYBackup)
clickInTheMiddle(firstStepper)
checkScrolling(flickable, contentXBackup, contentYBackup, style,
false, -1, "First stepper, first click")
contentXBackup = flickable.contentX
contentYBackup = flickable.contentY
//do it once more
clickInTheMiddle(firstStepper)
checkScrolling(flickable, contentXBackup, contentYBackup, style,
false, -1, "First stepper, second click")
}
//check that the mouse filters handling the interactions with the thumb and steppers
//ignore the synthesized events. This is required to have the correct hover handling,
//because it's the way we make sure that the hover logic is only called for real mouse
//events, and not touch-to-mouse synthesized events
function test_ignoreSynthesizedEventsInMouseFilters() {
var scrollbar = defaultValuesScrollbar
var style = scrollbar.__styleInstance
var thumbArea = getThumbArea(scrollbar)
var steppersMouseArea = getSteppersMouseArea(scrollbar)
compare(thumbArea.Mouse.ignoreSynthesizedEvents, true,
"The mouse filter in the thumb MouseArea does not ignore synthesized events. Hover state logic may be affected.")
compare(steppersMouseArea.Mouse.ignoreSynthesizedEvents, true,
"The mouse filter in the steppers MouseArea does not ignore synthesized events. Hover state logic may be affected.")
}
function test_defaultStylingValues() {
var scrollbar = defaultValuesScrollbar
var style = scrollbar.__styleInstance
/*****************************************************
* STYLING PROPERTIES *
*****************************************************/
compare(style.interactive, style.isMouseConnected || style.veryLongContentItem, "Wrong styling property default value.")
compare(style.minimumSliderSize, units.gu(1), "Wrong styling property default value.")
compare(style.overlay, !style.alwaysOnScrollbars, "Wrong styling property default value.")
compare(style.overlayOpacityWhenShown, 1.0, "Wrong styling property default value.")
compare(style.overlayOpacityWhenHidden, 0.0, "Wrong styling property default value.")
compare(style.troughThicknessSteppersStyle, units.dp(14), "Wrong styling property default value.")
compare(style.troughThicknessThumbStyle, units.dp(14), "Wrong styling property default value.")
compare(style.troughThicknessIndicatorStyle, units.dp(9), "Wrong styling property default value.")
compare(style.troughColorThumbStyle, theme.palette.normal.foreground, "Wrong styling property default value.")
compare(style.troughColorSteppersStyle, theme.palette.normal.foreground, "Wrong styling property default value.")
compare(style.stepperBgColor, theme.palette.normal.base, "Wrong styling property default value.")
compare(style.sliderColor, theme.palette.normal.overlayText, "Wrong styling property default value.")
compare(style.sliderRadius, units.dp(3), "Wrong styling property default value.")
compare(style.thumbThickness, units.gu(1), "Wrong styling property default value.")
compare(style.indicatorThickness, units.dp(3), "Wrong styling property default value.")
compare(style.scrollbarThicknessAnimation.duration, LomiriAnimation.SnapDuration, "Wrong styling property default value.")
compare(style.scrollbarFadeInAnimation.duration, LomiriAnimation.SlowDuration, "Wrong styling property default value.")
compare(style.scrollbarFadeOutAnimation.duration, LomiriAnimation.SlowDuration, "Wrong styling property default value.")
compare(style.scrollbarFadeOutPause, 3000, "Wrong styling property default value.")
compare(style.scrollbarCollapsePause, 1000, "Wrong styling property default value.")
compare(style.shortScrollingRatio, 0.1, "Wrong styling property default value.")
compare(style.longScrollingRatio, 0.9, "Wrong styling property default value.")
compare(style.hintingStyle, style.veryLongContentItem ? 'thumb' : 'indicator', "Wrong styling property default value.")
compare(style.thumbsExtremesMargin, units.dp(4), "Wrong styling property default value.")
/*****************************************************
* HELPER PROPERTIES *
*****************************************************/
var slider = getThumb(scrollbar)
var trough = getTrough(scrollbar)
compare(style.thumb, slider, "Wrong styling property default value.")
compare(style.trough, trough, "Wrong styling property default value.")
compare(style.isScrollable, scrollbar.__private.scrollable && style.pageSize > 0.0
&& style.contentSize > 0.0 && style.totalContentSize > style.pageSize, "Wrong styling property default value.")
compare(style.isVertical, (scrollbar.align === Qt.AlignLeading) || (scrollbar.align === Qt.AlignTrailing), "Wrong styling property default value.")
compare(style.frontAligned, scrollbar.align === Qt.AlignLeading, "Wrong styling property default value.")
compare(style.rearAligned, scrollbar.align === Qt.AlignTrailing, "Wrong styling property default value.")
compare(style.topAligned, scrollbar.align === Qt.AlignTop, "Wrong styling property default value.")
compare(style.bottomAligned, scrollbar.align === Qt.AlignBottom, "Wrong styling property default value.")
//flickable helper properties
compare(style.flickableItem, scrollbar.flickableItem, "Wrong styling property default value.")
compare(style.pageSize, (style.isVertical) ? (scrollbar.flickableItem.height) : (scrollbar.flickableItem.width), "Wrong styling property default value.")
compare(style.contentSize, (style.isVertical) ? scrollbar.flickableItem.contentHeight : scrollbar.flickableItem.contentWidth, "Wrong styling property default value.")
compare(style.leadingContentMargin, style.isVertical ? scrollbar.flickableItem.topMargin : scrollbar.flickableItem.leftMargin, "Wrong styling property default value.")
compare(style.trailingContentMargin, style.isVertical ? scrollbar.flickableItem.bottomMargin : scrollbar.flickableItem.rightMargin, "Wrong styling property default value.")
compare(style.totalContentSize, style.contentSize + style.leadingContentMargin + style.trailingContentMargin, "Wrong styling property default value.")
/*****************************************************
* INTERNAL PROPERTIES AND FUNCTIONS *
*****************************************************/
var thumbArea = getThumbArea(scrollbar)
var scrollAnimation = getScrollAnimation(scrollbar)
compare(style.__recursionGuard, false, "Wrong styling property default value.")
compare(style.__disableStateBinding, false, "Wrong styling property default value.")
compare(style.__hinting, false, "Wrong styling property default value.")
compare(style.draggingThumb, thumbArea.drag.active || slider.mouseDragging || slider.touchDragging, "Wrong styling property default value.")
compare(style.thumbStyleFlag, style.veryLongContentItem && (scrollbar.flickableItem.moving || scrollAnimation.running), "Wrong styling property default value.")
compare(style.veryLongContentItem, scrollbar.flickableItem && style.initialized
&& ((scrollbar.flickableItem.contentHeight > scrollbar.flickableItem.height * 10)
|| (scrollbar.flickableItem.contentWidth > scrollbar.flickableItem.width * 10)), "Wrong styling property default value.")
compare(style.isMouseConnected, true, "Wrong styling property default value.")
compare(style.nonOverlayScrollbarMargin, style.troughThicknessSteppersStyle, "Wrong styling property default value.")
compare(style.useSteppers, true, "Wrong styling property default value.")
compare(style.touchDragStartMargin, units.gu(2), "Wrong styling property default value.")
compare(style.dragThreshold, units.dp(2), "Wrong styling property default value.")
compare(style.alwaysOnScrollbars, scrollbar.__alwaysOnScrollbars, "Wrong styling property default value.")
}
//just a few tests to ensure the key variables don't get out of range values
//NOTE: this does not test that the properties have the correct value, just that
//their values is not out of range (so it only applies to numeric values)
function test_sanityCheckStylingVariables() {
flickableSanityCheck.contentHeight = contentSanityCheck.height
flickableSanityCheck.contentWidth = contentSanityCheck.width
performStyleSanityCheck(scrollbarSanityCheck)
flickableSanityCheck.contentHeight = -contentSanityCheck.height
flickableSanityCheck.contentWidth = -contentSanityCheck.width
performStyleSanityCheck(scrollbarSanityCheck)
flickableSanityCheck.topMargin = units.gu(1)
flickableSanityCheck.leftMargin = units.gu(2)
flickableSanityCheck.rightMargin = units.gu(3)
flickableSanityCheck.bottomMargin = units.gu(4)
performStyleSanityCheck(scrollbarSanityCheck)
flickableSanityCheck.topMargin = -units.gu(1)
flickableSanityCheck.leftMargin = -units.gu(2)
flickableSanityCheck.rightMargin = -units.gu(3)
flickableSanityCheck.bottomMargin = -units.gu(4)
performStyleSanityCheck(scrollbarSanityCheck)
}
//Test that Scrollbar defaults to Flickable.topMargin/bottomMargin (content margins)
//as its ANCHORS margins
function test_topBottomMargins(data) {
var freshTestItem = getFreshFlickable(data.alignment)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
compare(scrollbar.__styleInstance.isScrollable, true, "The view is not scrollable.")
compare(scrollbar.__styleInstance.alwaysOnScrollbars, false, "This test assumes overlay scrollbars (if you need to change this, fix the expected margins).")
compare(scrollbar.anchors.topMargin, flickable.topMargin, "Wrong anchors.topMargin.")
compare(scrollbar.anchors.bottomMargin, flickable.bottomMargin, "Wrong anchors.bottomMargin.")
flickable.topMargin = units.gu(1)
compare(scrollbar.anchors.topMargin, units.gu(1), "Wrong anchors.topMargin.")
compare(scrollbar.anchors.bottomMargin, flickable.bottomMargin, "Wrong anchors.bottomMargin.")
flickable.bottomMargin = units.gu(3)
compare(scrollbar.anchors.topMargin, units.gu(1), "Wrong anchors.topMargin.")
compare(scrollbar.anchors.bottomMargin, units.gu(3), "Wrong anchors.bottomMargin.")
flickable.topMargin = 0
flickable.bottomMargin = units.gu(6)
compare(scrollbar.anchors.topMargin, 0, "Wrong anchors.topMargin.")
compare(scrollbar.anchors.bottomMargin, units.gu(6), "Wrong anchors.bottomMargin.")
}
//check that we don't output lots of warnings when the flickable item becomes null
//(it could happen while transitioning values or before the Binding applies and similar situations)
function test_noWarningsWhenFlickableIsNull() {
var freshTestItem = getFreshFlickable(Qt.AlignTrailing)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
verify(scrollbar.flickableItem !== null, "Check that Scrollbar is linked to a Flickable.")
//try triggering warnings (they will be marked as failures by the SDK test runner)
scrollbar.flickableItem = null
var secondScrollbar = freshScrollbar.createObject(freshTestItem)
verify(secondScrollbar !== null, "Error: dynamic item creation failed.")
var style = secondScrollbar.__styleInstance
//check that the default value is correct
compare(style.flickableItem, null, "Wrong style flickableItem")
compare(scrollbar.flickableItem, null, "Wrong scrollbar's flickableItem")
compare(scrollbar.__initializedFlickable, null, "Wrong scrollbar's initialized flickable var")
//check that calling functions that rely on flickableItem doesn't output errors
style.scrollToBeginning()
style.scrollToEnd()
//This test will always pass if run with qmltestrunner, unfortunately there's no way
//using TestCase to do "if (testOutputsWarnings) --> fail", but the SDK test script
//will fail if this test outputs warnings, which is what we want
}
//test that __initializedFlickable has the right value even when
//the Scrollbar is assigned to one Flickable, then to another one (this could
//be useful to reuse the same instance of Scrollbar for multiple Flickables
//if they're only visible one at a time)
function test_initializedFlickableVariableChange() {
var freshTestItem = getFreshFlickable(Qt.AlignTrailing)
var flickable = freshTestItem.flickable
var scrollbar = freshTestItem.scrollbar
//check that the variables are correct when the Scrollbar is initialized with a set Flickable
compare(scrollbar.flickableItem, flickable, "Wrong value of flickableItem")
compare(scrollbar.__initializedFlickable, flickable, "Wrong value of __initializedFlickable")
var secondScrollbar = freshScrollbar.createObject(freshTestItem)
verify(secondScrollbar !== null, "Error: dynamic item creation failed.")
//check that the variables are correct when the Scrollbar is assigned a new Flickable
secondScrollbar.flickableItem = flickable
compare(secondScrollbar.flickableItem, flickable, "Wrong value of flickableItem")
compare(secondScrollbar.__initializedFlickable, flickable, "Wrong value of __initializedFlickable")
//set to null and check that both change
secondScrollbar.flickableItem = null
compare(secondScrollbar.flickableItem, null, "Wrong value of flickableItem")
compare(secondScrollbar.__initializedFlickable, null, "Wrong value of __initializedFlickable")
//set to a valid flickable again and check that both the variables are correctly updated
secondScrollbar.flickableItem = flickable
compare(secondScrollbar.flickableItem, flickable, "Wrong value of flickableItem")
compare(secondScrollbar.__initializedFlickable, flickable, "Wrong value of __initializedFlickable")
secondScrollbar.destroy()
}
}
}