ferdios/libqml6stretch e2b4771

Initial commit

Sander committed on 2026-09-04 · e2b4771

14 files changed +6706 −0

+ CMakeLists.txt
+ COPYING
+ COPYING.LESSER
+ LICENSE
+ README.md
+ cmake/Qml6StretchConfig.cmake.in
+ cmake/QtQmlInstallLayout.cmake
+ qml/StretchListView.qml
+ src/stretchflickable.cpp
+ src/stretchflickable_p.h
+ src/stretchflickable_p_p.h
+ src/stretchflickablebehavior_p.h
+ src/stretchtimeline.cpp
+ src/stretchtimeline_p_p.h

commit e2b4771717dae3fe135a8191c76b5e4e7cbe29d6
Author: Sander <sander@sanderf.nl>
Date:   Fri Sep 4 16:44:51 2026 +0300

    Initial commit

diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..d8d4421
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,156 @@
+cmake_minimum_required(VERSION 3.21)
+
+project(Qml6Stretch
+    VERSION 1.0.0
+    DESCRIPTION "Drag-resistant Flickable and ListView-alike QML components for Qt6"
+    LANGUAGES CXX
+)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+endif()
+
+set(CMAKE_AUTOMOC ON)
+
+include(CMakePackageConfigHelpers)
+
+find_package(Qt6 6.5 REQUIRED COMPONENTS
+    Core
+    Gui
+    Qml
+    Quick
+    CorePrivate
+    GuiPrivate
+    QmlPrivate
+    QuickPrivate
+)
+
+qt_standard_project_setup()
+
+qt_policy(SET QTP0001 NEW)
+qt_policy(SET QTP0004 NEW)
+
+# Derives the install prefix and QML module destination from the Qt being built
+# against, so the module lands in Qt's own import dir. Includes GNUInstallDirs.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+include(QtQmlInstallLayout)
+
+qt6_add_qml_module(qml6stretch
+    URI Qml6Stretch
+    VERSION 1.0
+    SHARED
+    PLUGIN_TARGET qml6stretchplugin
+    OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/qml/Qml6Stretch"
+    SOURCES
+        src/stretchflickable_p.h
+        src/stretchflickable_p_p.h
+        src/stretchflickable.cpp
+        src/stretchflickablebehavior_p.h
+        src/stretchtimeline_p_p.h
+        src/stretchtimeline.cpp
+    QML_FILES
+        qml/StretchListView.qml
+)
+
+set_target_properties(qml6stretch PROPERTIES
+    VERSION ${PROJECT_VERSION}
+    SOVERSION ${PROJECT_VERSION_MAJOR}
+)
+
+# qt_standard_project_setup() assumes a one-level-deep layout ($ORIGIN/../lib);
+# the plugin lives deeper, under Qt's qml dir.
+qt_qml_plugin_rpath(_plugin_rpath Qml6Stretch)
+set_target_properties(qml6stretchplugin PROPERTIES INSTALL_RPATH "${_plugin_rpath}")
+
+target_include_directories(qml6stretch PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/qml6stretch>
+)
+
+target_link_libraries(qml6stretch PUBLIC
+    Qt6::Core
+    Qt6::Gui
+    Qt6::Qml
+    Qt6::Quick
+    Qt6::CorePrivate
+    Qt6::GuiPrivate
+    Qt6::QmlPrivate
+    Qt6::QuickPrivate
+)
+
+# ---- Installation ---------------------------------------------------------
+
+install(FILES
+    src/stretchflickable_p.h
+    src/stretchflickable_p_p.h
+    src/stretchflickablebehavior_p.h
+    src/stretchtimeline_p_p.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/qml6stretch
+)
+
+install(TARGETS qml6stretch
+    EXPORT Qml6StretchTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(TARGETS qml6stretchplugin
+    EXPORT Qml6StretchTargets
+    LIBRARY DESTINATION ${QT_QML_MODULE_INSTALL_DIR}/Qml6Stretch
+    RUNTIME DESTINATION ${QT_QML_MODULE_INSTALL_DIR}/Qml6Stretch
+)
+
+# qmldir records QML_FILES by their relative on-disk path (e.g.
+# "qml/StretchListView.qml"). They're also embedded as a resource inside
+# qml6stretchplugin, but Qt's static-plugin import scanner (qt6_import_qml_plugins,
+# used when consuming apps link Qt statically) still opens that path on disk
+# at configure time, so the loose file has to ship alongside qmldir too.
+install(FILES
+    qml/StretchListView.qml
+    DESTINATION ${QT_QML_MODULE_INSTALL_DIR}/Qml6Stretch/qml
+)
+
+install(FILES
+    "${CMAKE_BINARY_DIR}/qml/Qml6Stretch/qmldir"
+    DESTINATION ${QT_QML_MODULE_INSTALL_DIR}/Qml6Stretch
+)
+
+install(FILES
+    "${CMAKE_BINARY_DIR}/qml/Qml6Stretch/qml6stretch.qmltypes"
+    DESTINATION ${QT_QML_MODULE_INSTALL_DIR}/Qml6Stretch
+    OPTIONAL
+)
+
+# ---- CMake package config for find_package() ------------------------------
+
+install(EXPORT Qml6StretchTargets
+    FILE Qml6StretchTargets.cmake
+    NAMESPACE Qml6Stretch::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Qml6Stretch
+)
+
+configure_package_config_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Qml6StretchConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/Qml6StretchConfig.cmake"
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Qml6Stretch
+    PATH_VARS QT_QML_MODULE_INSTALL_FULL_DIR
+)
+
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/Qml6StretchConfigVersion.cmake"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/Qml6StretchConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/Qml6StretchConfigVersion.cmake"
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Qml6Stretch
+)
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..f288702
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/COPYING.LESSER b/COPYING.LESSER
new file mode 100644
index 0000000..0a04128
--- /dev/null
+++ b/COPYING.LESSER
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..0a04128
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..346a971
--- /dev/null
+++ b/README.md
@@ -0,0 +1,126 @@
+# Qml6Stretch
+
+loooong components
+
+Installs *into your Qt6 installation* (`QT_INSTALL_QML` and friends), so
+consuming projects only need `find_package`:
+
+- `<qt>/qml/Qml6Stretch/` - the importable `Qml6Stretch` QML module
+  (`libqml6stretchplugin.so`, `qmldir`, `qml6stretch.qmltypes`)
+- `<qt>/lib/libqml6stretch.so.<version>`
+- `<qt>/include/qml6stretch/*.h` - `#include <qml6stretch/stretchflickable_p.h>`
+- `<qt>/lib/cmake/Qml6Stretch/` - CMake package config for `find_package()`
+
+## Building
+
+```sh
+cmake -S . -B build -DCMAKE_PREFIX_PATH=/path/to/Qt/6.x.y/gcc_64
+cmake --build build -j
+cmake --install build
+```
+
+The install prefix defaults to that Qt's prefix; the QML module destination
+comes from `qmake -query QT_INSTALL_QML` on the qmake belonging to *that* Qt
+(not whatever `qmake6` is first on `PATH`). Pass `-DCMAKE_INSTALL_PREFIX=...`
+to install elsewhere, `-DQT_QML_INSTALL_INTO_QT=OFF` for a plain standalone
+`<prefix>/qml` layout, or `-DQT_QMAKE_EXECUTABLE=...` to pin the qmake.
+
+## Consuming it from CMake
+
+```cmake
+find_package(Qml6Stretch REQUIRED CONFIG)
+
+qt_add_qml_module(myapp
+    URI App
+    VERSION 1.0
+    QML_FILES qml/Main.qml
+)
+
+target_link_libraries(myapp PRIVATE Qml6Stretch::qml6stretch)
+```
+
+No `IMPORT_PATH`, `QML_IMPORT_PATH` or compile definitions needed: the module
+lives in Qt's own import directory, so `import Qml6Stretch` resolves for
+qmllint, qmlls and the QML engine at runtime. (`Qml6Stretch_QML_DIR` is still
+set by the package config, for non-default install layouts.)
+
+## Usage from QML
+
+```qml
+import QtQuick
+import Qml6Stretch
+
+Rectangle {
+    anchors.fill: parent
+    color: "black"
+
+    StretchListView {
+        id: list
+        anchors.fill: parent
+        model: rowModel
+        delegate: rowDelegate
+        spacing: 8
+
+        // optional: tune the rubber-band feel
+        dragResistanceRange: 600
+        dragOvershootMax: 50
+    }
+
+    ListModel {
+        id: rowModel
+        ListElement { label: "Item 1"; bgColor: "#00B4D8" }
+        ListElement { label: "Item 2"; bgColor: "#07AFD5" }
+        // ...
+    }
+
+    Component {
+        id: rowDelegate
+        Rectangle {
+            required property string label
+            required property color bgColor
+
+            width: list.width
+            height: 128
+            radius: 12
+            color: bgColor
+
+            Text {
+                anchors.centerIn: parent
+                text: label
+                color: "white"
+            }
+        }
+    }
+}
+```
+
+Or use `StretchFlickable` directly, like `Flickable`:
+
+```qml
+import QtQuick
+import Qml6Stretch
+
+StretchFlickable {
+    anchors.fill: parent
+    contentWidth: width
+    contentHeight: column.height
+    clip: true
+    boundsBehavior: StretchFlickable.DragOverBounds
+    dragResistanceRange: 600
+    dragOvershootMax: 50
+
+    Column {
+        id: column
+        width: parent.width
+        // ... your content ...
+    }
+}
+```
+
+## License
+
+Qml6Stretch is licensed under the
+[GNU Lesser General Public License v3.0](LICENSE) (LGPL-3.0). It is
+derived from Qt's own `QQuickFlickable`/`QQuickTimeLine` sources
+(`LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR
+GPL-3.0-only`), and is distributed here under the LGPL-3.0 option.
diff --git a/cmake/Qml6StretchConfig.cmake.in b/cmake/Qml6StretchConfig.cmake.in
new file mode 100644
index 0000000..1633dde
--- /dev/null
+++ b/cmake/Qml6StretchConfig.cmake.in
@@ -0,0 +1,20 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+find_dependency(Qt6 @Qt6_VERSION@ COMPONENTS
+    Core
+    Gui
+    Qml
+    Quick
+    CorePrivate
+    GuiPrivate
+    QmlPrivate
+    QuickPrivate
+)
+
+include("${CMAKE_CURRENT_LIST_DIR}/Qml6StretchTargets.cmake")
+
+set_and_check(Qml6Stretch_QML_DIR "@PACKAGE_QT_QML_MODULE_INSTALL_FULL_DIR@")
+
+check_required_components(Qml6Stretch)
diff --git a/cmake/QtQmlInstallLayout.cmake b/cmake/QtQmlInstallLayout.cmake
new file mode 100644
index 0000000..03a382a
--- /dev/null
+++ b/cmake/QtQmlInstallLayout.cmake
@@ -0,0 +1,130 @@
+# Install layout for projects shipping a QML module. Include after find_package(Qt6).
+#
+# Targets Qt's own import dir (QT_INSTALL_QML) so consumers get `import <URI>`
+# with no IMPORT_PATH / QML_IMPORT_PATH plumbing. Defines:
+#
+#   QT_QML_INSTALL_INTO_QT     option, ON
+#   QT_INSTALL_QML_DIR         Qt's QML import dir, absolute
+#   QT_QML_MODULE_INSTALL_DIR  cache var, install destination (prefix-relative
+#                              where possible), "qml" when the option is OFF
+#   QT_QML_MODULE_INSTALL_FULL_DIR   same, absolute
+#   QT_QMAKE_EXECUTABLE        the qmake of the Qt being built against
+#   qt_qml_plugin_rpath(<out> <subdir>)   RPATH for a plugin at <qml-dir>/<subdir>
+#
+# Also includes GNUInstallDirs, since it may first default CMAKE_INSTALL_PREFIX
+# to Qt's prefix and GNUInstallDirs' libdir choice depends on that.
+
+if(NOT TARGET Qt6::Core)
+    message(FATAL_ERROR "QtQmlInstallLayout must be included after find_package(Qt6).")
+endif()
+
+# Find the qmake of the Qt that find_package(Qt6) resolved - not whatever
+# qmake6 happens to be first on PATH.
+
+# 1. Qt's own imported tool target, when available.
+if(NOT QT_QMAKE_EXECUTABLE AND TARGET Qt6::qmake)
+    get_target_property(QT_QMAKE_EXECUTABLE Qt6::qmake IMPORTED_LOCATION)
+endif()
+
+# 2. Next to the Qt6Config.cmake we loaded (Qt6_DIR is <prefix>/lib/cmake/Qt6).
+if(NOT QT_QMAKE_EXECUTABLE)
+    set(_hints "")
+    if(QT6_INSTALL_PREFIX)
+        list(APPEND _hints "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_BINS}" "${QT6_INSTALL_PREFIX}/bin")
+    endif()
+    if(Qt6_DIR)
+        get_filename_component(_qtprefix "${Qt6_DIR}/../../.." ABSOLUTE)
+        list(APPEND _hints "${_qtprefix}/bin")
+    endif()
+    find_program(QT_QMAKE_EXECUTABLE NAMES qmake6 qmake HINTS ${_hints} NO_DEFAULT_PATH
+        DOC "qmake of the Qt6 being built against")
+endif()
+
+# 3. Last resort: PATH. Still has to pass the prefix cross-check below.
+if(NOT QT_QMAKE_EXECUTABLE)
+    find_program(QT_QMAKE_EXECUTABLE NAMES qmake6 qmake
+        DOC "qmake of the Qt6 being built against")
+endif()
+
+set(QT_INSTALL_QML_DIR "")
+
+if(QT_QMAKE_EXECUTABLE)
+    execute_process(COMMAND "${QT_QMAKE_EXECUTABLE}" -query QT_INSTALL_QML
+        OUTPUT_VARIABLE _qml_dir OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET RESULT_VARIABLE _qmake_result)
+    execute_process(COMMAND "${QT_QMAKE_EXECUTABLE}" -query QT_INSTALL_PREFIX
+        OUTPUT_VARIABLE _qmake_prefix OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
+
+    # Reject a qmake from a different Qt (distro qmake6 on PATH vs. the Qt in
+    # CMAKE_PREFIX_PATH) - installing into its qml dir would be silently wrong.
+    if(_qmake_result EQUAL 0 AND _qml_dir AND QT6_INSTALL_PREFIX AND _qmake_prefix)
+        get_filename_component(_a "${QT6_INSTALL_PREFIX}" REALPATH)
+        get_filename_component(_b "${_qmake_prefix}" REALPATH)
+        if(NOT _a STREQUAL _b)
+            message(WARNING "Ignoring ${QT_QMAKE_EXECUTABLE}: reports prefix "
+                "'${_qmake_prefix}', but this build uses Qt at '${QT6_INSTALL_PREFIX}'.")
+            set(_qml_dir "")
+        endif()
+    endif()
+    if(_qmake_result EQUAL 0)
+        set(QT_INSTALL_QML_DIR "${_qml_dir}")
+    endif()
+endif()
+
+# Fallback for a Qt without a usable qmake (QT6_INSTALL_QML is prefix-relative).
+if(NOT QT_INSTALL_QML_DIR AND QT6_INSTALL_PREFIX AND QT6_INSTALL_QML)
+    set(QT_INSTALL_QML_DIR "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_QML}")
+endif()
+
+option(QT_QML_INSTALL_INTO_QT
+    "Install into the Qt6 installation itself, so consumers need no import paths" ON)
+
+if(QT_QML_INSTALL_INTO_QT AND NOT QT_INSTALL_QML_DIR)
+    message(FATAL_ERROR "Could not determine QT_INSTALL_QML. Set QT_QMAKE_EXECUTABLE "
+        "to the right qmake6, or configure with -DQT_QML_INSTALL_INTO_QT=OFF.")
+endif()
+
+# Default the prefix to Qt's, unless one was given on the command line.
+if(QT_QML_INSTALL_INTO_QT AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
+    if(QT6_INSTALL_PREFIX)
+        set(_prefix "${QT6_INSTALL_PREFIX}")
+    else()
+        get_filename_component(_prefix "${QT_INSTALL_QML_DIR}/.." ABSOLUTE)
+    endif()
+    set(CMAKE_INSTALL_PREFIX "${_prefix}" CACHE PATH
+        "Install path prefix (defaults to the Qt6 installation)" FORCE)
+endif()
+
+include(GNUInstallDirs)
+
+# QML import resolution looks for <import-path>/<URI>/qmldir, so this is kept
+# separate from CMAKE_INSTALL_LIBDIR. Prefer a prefix-relative path to keep the
+# install tree relocatable and DESTDIR working.
+if(QT_QML_INSTALL_INTO_QT)
+    file(RELATIVE_PATH _qml_rel "${CMAKE_INSTALL_PREFIX}" "${QT_INSTALL_QML_DIR}")
+    if(_qml_rel STREQUAL "" OR _qml_rel MATCHES "^\\.\\.")
+        set(_qml_rel "${QT_INSTALL_QML_DIR}")  # prefix overridden away from Qt
+    endif()
+else()
+    set(_qml_rel "qml")
+endif()
+
+set(QT_QML_MODULE_INSTALL_DIR "${_qml_rel}" CACHE STRING
+    "Install location (relative to CMAKE_INSTALL_PREFIX) of this project's QML module")
+
+if(IS_ABSOLUTE "${QT_QML_MODULE_INSTALL_DIR}")
+    set(QT_QML_MODULE_INSTALL_FULL_DIR "${QT_QML_MODULE_INSTALL_DIR}")
+else()
+    set(QT_QML_MODULE_INSTALL_FULL_DIR "${CMAKE_INSTALL_PREFIX}/${QT_QML_MODULE_INSTALL_DIR}")
+endif()
+
+# A QML plugin sits at <qml-dir>/<subdir> and must find its backing library in
+# <prefix>/<libdir>; the hop between them depends on where Qt's qml dir is.
+function(qt_qml_plugin_rpath out_var subdir)
+    file(RELATIVE_PATH _rel "${QT_QML_MODULE_INSTALL_FULL_DIR}/${subdir}"
+        "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+    set(${out_var} "$ORIGIN/${_rel}" PARENT_SCOPE)
+endfunction()
+
+message(STATUS "${PROJECT_NAME}: prefix         = ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "${PROJECT_NAME}: QML module dir = ${QT_QML_MODULE_INSTALL_DIR}")
diff --git a/qml/StretchListView.qml b/qml/StretchListView.qml
new file mode 100644
index 0000000..aa8e84a
--- /dev/null
+++ b/qml/StretchListView.qml
@@ -0,0 +1,83 @@
+import QtQuick
+import Qml6Stretch
+
+// Minimal ListView-alike: vertical Column + Repeater riding inside a
+// StretchFlickable, so scrolling gets the same drag-resistance/overshoot
+// feel as CoolGrid without forking QQuickListView's C++ internals.
+Item {
+    id: root
+
+    property alias model: repeater.model
+    property alias delegate: repeater.delegate
+    property real spacing: 0
+    property int currentIndex: -1
+    readonly property int count: repeater.count
+    readonly property Item currentItem: currentIndex >= 0 ? repeater.itemAt(currentIndex) : null
+
+    property alias interactive: flick.interactive
+    property alias contentY: flick.contentY
+    readonly property real contentHeight: column.height
+    property alias dragResistanceRange: flick.dragResistanceRange
+    property alias dragOvershootMax: flick.dragOvershootMax
+
+    function positionViewAtBeginning() {
+        flick.contentY = 0
+    }
+
+    function positionViewAtEnd() {
+        flick.contentY = Math.max(0, column.height - flick.height)
+    }
+
+    function positionViewAtIndex(index) {
+        const item = repeater.itemAt(index)
+        if (!item)
+            return
+        flick.contentY = Math.max(0, Math.min(item.y, Math.max(0, column.height - flick.height)))
+    }
+
+    // how far contentY sits past [0, maxContentY] - negative at the top,
+    // positive at the bottom; turned into a stretch below instead of a slide
+    readonly property real overscrollStretch: {
+        const t = Math.min(1, Math.abs(flick.overshootY) / 250)
+        const eased = 1 - Math.pow(1 - t, 3)
+        return eased * 0.15
+    }
+
+    StretchFlickable {
+        id: flick
+        anchors.fill: parent
+        contentWidth: width
+        contentHeight: column.height + 32
+        clip: true
+        // rubber-band only while actively dragging past the bounds - a hard
+        // flick should decelerate to a stop at the edge, not bounce once
+        // released (no OvershootBounds)
+        boundsBehavior: StretchFlickable.DragOverBounds
+
+        readonly property real maxContentY: Math.max(0, contentHeight - height)
+        readonly property real overshootY: contentY - Math.max(0, Math.min(contentY, maxContentY))
+
+        Column {
+            id: column
+            width: flick.width
+            spacing: root.spacing
+
+            // cancels Flickable's -contentY translation for just the overshoot
+            // portion, pinning the column at its top/bottom-most position
+            // instead of sliding past it
+            y: flick.overshootY
+
+            // ...replaces the cancelled slide with a stretch from the pulled
+            // edge, so that edge stays put while the column elongates
+            transform: Scale {
+                origin.x: 0
+                origin.y: flick.overshootY < 0 ? 0 : column.height
+                yScale: 1 + root.overscrollStretch
+            }
+
+            Repeater {
+                id: repeater
+            }
+        }
+    }
+}
diff --git a/src/stretchflickable.cpp b/src/stretchflickable.cpp
new file mode 100644
index 0000000..08ed2cd
--- /dev/null
+++ b/src/stretchflickable.cpp
@@ -0,0 +1,3417 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "stretchflickable_p.h"
+#include "stretchflickable_p_p.h"
+#include "stretchflickablebehavior_p.h"
+#include <QtQuick/qquickwindow.h>
+#include <QtQuick/private/qquickwindow_p.h>
+#include <QtQuick/private/qquickmousearea_p.h>
+#if QT_CONFIG(quick_draganddrop)
+#include <QtQuick/private/qquickdrag_p.h>
+#endif
+
+#include <QtQuick/private/qquickpointerhandler_p.h>
+#include <QtQuick/private/qquicktransition_p.h>
+#include <private/qqmlglobal_p.h>
+
+#include <QtQml/qqmlinfo.h>
+#include <QtGui/qevent.h>
+#include <QtGui/qguiapplication.h>
+#include <QtGui/private/qguiapplication_p.h>
+#include <QtGui/private/qeventpoint_p.h>
+#include <QtGui/qstylehints.h>
+#include <QtGui/qaccessible.h>
+#include <QtCore/qmath.h>
+#include <qpa/qplatformtheme.h>
+
+#include <math.h>
+#include <cmath>
+
+QT_BEGIN_NAMESPACE
+
+Q_STATIC_LOGGING_CATEGORY(lcFlickable, "qt.quick.flickable")
+Q_STATIC_LOGGING_CATEGORY(lcFilter, "qt.quick.flickable.filter")
+Q_STATIC_LOGGING_CATEGORY(lcReplay, "qt.quick.flickable.replay")
+Q_STATIC_LOGGING_CATEGORY(lcWheel, "qt.quick.flickable.wheel")
+Q_STATIC_LOGGING_CATEGORY(lcVel, "qt.quick.flickable.velocity")
+// QtQuick's own lcHandlerParent (qquickitem_p.h) has no exported definition on
+// this build (it's only declared, not Q_QUICK_EXPORTed) - use our own instead,
+// under a different name so it doesn't clash with that (still visible) declaration.
+Q_STATIC_LOGGING_CATEGORY(lcStretchHandlerParent, "qt.quick.handler.parent")
+
+// RetainGrabVelocity is the maxmimum instantaneous velocity that
+// will ensure the Flickable retains the grab on consecutive flicks.
+static const int RetainGrabVelocity = 100;
+
+static qreal EaseOvershoot(qreal t) {
+    return qAtan(t);
+}
+
+// Drag-over-bounds resistance curve: rawOvershoot is how far past the bound
+// the finger would be with zero resistance; maps it into [0, maxOvershoot)
+// using the same atan shape as EaseOvershoot above, but normalized by pi/2 so
+// it asymptotes at exactly maxOvershoot instead of maxOvershoot * pi/2.
+// resistanceDistance is the raw-drag distance needed to approach that cap -
+// larger means more resistance (you have to drag much further for the same
+// visual stretch).
+static qreal dragResistanceCurve(qreal rawOvershoot, qreal resistanceDistance, qreal maxOvershoot) {
+    return maxOvershoot * (2.0 / M_PI) * qAtan(rawOvershoot / resistanceDistance);
+}
+
+StretchFlickableVisibleArea::StretchFlickableVisibleArea(StretchFlickable *parent)
+    : QObject(parent), flickable(parent), m_xPosition(0.), m_widthRatio(0.)
+    , m_yPosition(0.), m_heightRatio(0.)
+{
+}
+
+qreal StretchFlickableVisibleArea::widthRatio() const
+{
+    return m_widthRatio;
+}
+
+qreal StretchFlickableVisibleArea::xPosition() const
+{
+    return m_xPosition;
+}
+
+qreal StretchFlickableVisibleArea::heightRatio() const
+{
+    return m_heightRatio;
+}
+
+qreal StretchFlickableVisibleArea::yPosition() const
+{
+    return m_yPosition;
+}
+
+void StretchFlickableVisibleArea::updateVisible()
+{
+    StretchFlickablePrivate *p = StretchFlickablePrivate::get(flickable);
+
+    bool changeX = false;
+    bool changeY = false;
+    bool changeWidth = false;
+    bool changeHeight = false;
+
+    // Vertical
+    const qreal viewheight = flickable->height();
+    const qreal maxyextent = -flickable->maxYExtent() + flickable->minYExtent();
+    const qreal maxYBounds = maxyextent + viewheight;
+    qreal pagePos = 0;
+    qreal pageSize = 0;
+    if (!qFuzzyIsNull(maxYBounds)) {
+        qreal y = p->pixelAligned ? std::round(p->vData.move.value()) : p->vData.move.value();
+        pagePos = (-y + flickable->minYExtent()) / maxYBounds;
+        pageSize = viewheight / maxYBounds;
+    }
+
+    if (pageSize != m_heightRatio) {
+        m_heightRatio = pageSize;
+        changeHeight = true;
+    }
+    if (pagePos != m_yPosition) {
+        m_yPosition = pagePos;
+        changeY = true;
+    }
+
+    // Horizontal
+    const qreal viewwidth = flickable->width();
+    const qreal maxxextent = -flickable->maxXExtent() + flickable->minXExtent();
+    const qreal maxXBounds = maxxextent + viewwidth;
+    if (!qFuzzyIsNull(maxXBounds)) {
+        qreal x = p->pixelAligned ? std::round(p->hData.move.value()) : p->hData.move.value();
+        pagePos = (-x + flickable->minXExtent()) / maxXBounds;
+        pageSize = viewwidth / maxXBounds;
+    } else {
+        pagePos = 0;
+        pageSize = 0;
+    }
+
+    if (pageSize != m_widthRatio) {
+        m_widthRatio = pageSize;
+        changeWidth = true;
+    }
+    if (pagePos != m_xPosition) {
+        m_xPosition = pagePos;
+        changeX = true;
+    }
+
+    if (changeX)
+        emit xPositionChanged(m_xPosition);
+    if (changeY)
+        emit yPositionChanged(m_yPosition);
+    if (changeWidth)
+        emit widthRatioChanged(m_widthRatio);
+    if (changeHeight)
+        emit heightRatioChanged(m_heightRatio);
+}
+
+
+class StretchFlickableReboundTransition : public QQuickTransitionManager
+{
+public:
+    StretchFlickableReboundTransition(StretchFlickable *f, const QString &name)
+        : flickable(f), axisData(nullptr), propName(name), active(false)
+    {
+    }
+
+    ~StretchFlickableReboundTransition()
+    {
+        flickable = nullptr;
+    }
+
+    bool startTransition(StretchFlickablePrivate::AxisData *data, qreal toPos) {
+        StretchFlickablePrivate *fp = StretchFlickablePrivate::get(flickable);
+        if (!fp->rebound || !fp->rebound->enabled())
+            return false;
+        active = true;
+        axisData = data;
+        axisData->transitionTo = toPos;
+        axisData->transitionToSet = true;
+
+        actions.clear();
+        actions << QQuickStateAction(fp->contentItem, propName, toPos);
+        QQuickTransitionManager::transition(actions, fp->rebound, fp->contentItem);
+        return true;
+    }
+
+    bool isActive() const {
+        return active;
+    }
+
+    void stopTransition() {
+        if (!flickable || !isRunning())
+            return;
+        StretchFlickablePrivate *fp = StretchFlickablePrivate::get(flickable);
+        if (axisData == &fp->hData)
+            axisData->move.setValue(-flickable->contentX());
+        else
+            axisData->move.setValue(-flickable->contentY());
+        active = false;
+        cancel();
+    }
+
+protected:
+    void finished() override {
+        if (!flickable)
+            return;
+        axisData->move.setValue(axisData->transitionTo);
+        StretchFlickablePrivate *fp = StretchFlickablePrivate::get(flickable);
+        active = false;
+
+        if (!fp->hData.transitionToBounds->isActive()
+                && !fp->vData.transitionToBounds->isActive()) {
+            flickable->movementEnding();
+        }
+    }
+
+private:
+    QQuickStateOperation::ActionList actions;
+    StretchFlickable *flickable;
+    StretchFlickablePrivate::AxisData *axisData;
+    QString propName;
+    bool active;
+};
+
+StretchFlickablePrivate::AxisData::~AxisData()
+{
+    delete transitionToBounds;
+}
+
+class StretchFlickableContentItem : public QQuickItem
+{
+    /*!
+        \internal
+        The flickable area inside the viewport can be bigger than the bounds of the
+        content item itself, if the flickable is using non-zero extents (as returned
+        by e.g minXExtent()). Since the default implementation in QQuickItem::contains()
+        only checks if the point is inside the bounds of the item, we need to override it
+        to check the extents as well. The easist way to do this is to simply check if the
+        point is inside the bounds of the flickable rather than the content item.
+    */
+    bool contains(const QPointF &point) const override
+    {
+        const QQuickItem *flickable = parentItem();
+        const QPointF posInFlickable = flickable->mapFromItem(this, point);
+        return flickable->contains(posInFlickable);
+    }
+};
+
+StretchFlickablePrivate::StretchFlickablePrivate()
+  : contentItem(new StretchFlickableContentItem)
+    , hData(this, &StretchFlickablePrivate::setViewportX)
+    , vData(this, &StretchFlickablePrivate::setViewportY)
+    , hMoved(false), vMoved(false)
+    , stealMouse(false), pressed(false)
+    , scrollingPhase(false), interactive(true), calcVelocity(false)
+    , pixelAligned(false)
+    , syncDrag(false)
+    , acceptedButtons(Qt::LeftButton)
+    , lastPosTime(-1)
+    , lastPressTime(0)
+    , deceleration(QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::FlickDeceleration).toReal())
+    , wheelDeceleration(15000)
+    , maxVelocity(QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::FlickMaximumVelocity).toReal())
+    , delayedPressEvent(nullptr), pressDelay(0), fixupDuration(400)
+    , flickBoost(1.0), initialWheelFlickDistance(qApp->styleHints()->wheelScrollLines() * 24)
+    , fixupMode(Normal), vTime(0), visibleArea(nullptr)
+    , flickableDirection(StretchFlickable::AutoFlickDirection)
+    , boundsBehavior(StretchFlickable::DragAndOvershootBounds)
+    , boundsMovement(StretchFlickable::FollowBoundsBehavior)
+    , rebound(nullptr)
+{
+    const int wheelDecelerationEnv = qEnvironmentVariableIntValue("QT_QUICK_FLICKABLE_WHEEL_DECELERATION");
+    if (wheelDecelerationEnv > 0)
+        wheelDeceleration = wheelDecelerationEnv;
+}
+
+void StretchFlickablePrivate::init()
+{
+    Q_Q(StretchFlickable);
+    QQml_setParent_noEvent(contentItem, q);
+    contentItem->setParentItem(q);
+    qmlobject_connect(&timeline, StretchTimeLine, SIGNAL(completed()),
+                      q, StretchFlickable, SLOT(timelineCompleted()));
+    qmlobject_connect(&velocityTimeline, StretchTimeLine, SIGNAL(completed()),
+                      q, StretchFlickable, SLOT(velocityTimelineCompleted()));
+    q->setAcceptedMouseButtons(acceptedButtons);
+    q->setAcceptTouchEvents(true);
+    q->setFiltersChildMouseEvents(true);
+    q->setFlag(QQuickItem::ItemIsViewport);
+    QQuickItemPrivate *viewportPrivate = QQuickItemPrivate::get(contentItem);
+    viewportPrivate->addItemChangeListener(this, QQuickItemPrivate::Geometry);
+    setSizePolicy(QLayoutPolicy::Expanding, QLayoutPolicy::Expanding);
+}
+
+/*!
+    \internal
+    Returns the distance to overshoot, given \a velocity.
+    Will be in range 0 - velocity / 3, but limited to a max of QML_FLICK_OVERSHOOT
+*/
+qreal StretchFlickablePrivate::overShootDistance(qreal velocity) const
+{
+    if (maxVelocity <= 0)
+        return 0;
+
+    return qMin(qreal(QML_FLICK_OVERSHOOT), velocity / 3);
+}
+
+qreal StretchFlickablePrivate::dragOvershootRange() const
+{
+    return dragResistanceRange * devicePixelRatio();
+}
+
+qreal StretchFlickablePrivate::dragOvershootMaxPixels() const
+{
+    return dragOvershootMax * devicePixelRatio();
+}
+
+void StretchFlickablePrivate::AxisData::addVelocitySample(qreal v, qreal maxVelocity)
+{
+    if (v > maxVelocity)
+        v = maxVelocity;
+    else if (v < -maxVelocity)
+        v = -maxVelocity;
+    velocityBuffer.append(v);
+    if (velocityBuffer.count() > QML_FLICK_SAMPLEBUFFER)
+        velocityBuffer.remove(0);
+}
+
+void StretchFlickablePrivate::AxisData::updateVelocity()
+{
+    velocity = 0;
+    if (velocityBuffer.count() > QML_FLICK_DISCARDSAMPLES) {
+        int count = velocityBuffer.count()-QML_FLICK_DISCARDSAMPLES;
+        for (int i = 0; i < count; ++i) {
+            qreal v = velocityBuffer.at(i);
+            velocity += v;
+        }
+        velocity /= count;
+    }
+}
+
+void StretchFlickablePrivate::itemGeometryChanged(QQuickItem *item, QQuickGeometryChange change, const QRectF &oldGeom)
+{
+    Q_Q(StretchFlickable);
+    if (item == contentItem) {
+        Qt::Orientations orient;
+        if (change.xChange())
+            orient |= Qt::Horizontal;
+        if (change.yChange())
+            orient |= Qt::Vertical;
+        if (orient) {
+            q->viewportMoved(orient);
+            const QPointF deltaMoved = item->position() - oldGeom.topLeft();
+            if (hData.contentPositionChangedExternallyDuringDrag)
+                hData.pressPos += deltaMoved.x();
+            if (vData.contentPositionChangedExternallyDuringDrag)
+                vData.pressPos += deltaMoved.y();
+        }
+        if (orient & Qt::Horizontal)
+            emit q->contentXChanged();
+        if (orient & Qt::Vertical)
+            emit q->contentYChanged();
+    }
+}
+
+bool StretchFlickablePrivate::flickX(QEvent::Type eventType, qreal velocity)
+{
+    Q_Q(StretchFlickable);
+    return flick(hData, q->minXExtent(), q->maxXExtent(), q->width(), fixupX_callback, eventType, velocity);
+}
+
+bool StretchFlickablePrivate::flickY(QEvent::Type eventType, qreal velocity)
+{
+    Q_Q(StretchFlickable);
+    return flick(vData, q->minYExtent(), q->maxYExtent(), q->height(), fixupY_callback, eventType, velocity);
+}
+
+bool StretchFlickablePrivate::flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal,
+                                   StretchTimeLineCallback::Callback fixupCallback,
+                                   QEvent::Type eventType, qreal velocity)
+{
+    Q_Q(StretchFlickable);
+
+    // Releasing while already dragged past the bounds: don't let residual
+    // velocity launch it further into overshoot - snap straight back to the
+    // bound immediately, no matter how hard the flick was. (This only covers
+    // the drag-overshoot case; inOvershoot, checked below, covers the
+    // separate case of momentum carrying it past the bounds mid-flick.)
+    const bool draggedPastBounds = (data.move.value() > minExtent)
+            || (data.move.value() < maxExtent && maxExtent - minExtent <= 0);
+    if (draggedPastBounds) {
+        resetTimeline(data);
+        fixup(data, minExtent, maxExtent);
+        return false;
+    }
+
+    qreal maxDistance = -1;
+    data.fixingUp = false;
+    // -ve velocity means list is moving up
+    if (velocity > 0) {
+        maxDistance = qAbs(minExtent - data.move.value());
+        data.flickTarget = minExtent;
+    } else {
+        maxDistance = qAbs(maxExtent - data.move.value());
+        data.flickTarget = maxExtent;
+    }
+    if (maxDistance > 0 || boundsBehavior & StretchFlickable::OvershootBounds) {
+        qreal v = velocity;
+        if (maxVelocity != -1 && maxVelocity < qAbs(v)) {
+            if (v < 0)
+                v = -maxVelocity;
+            else
+                v = maxVelocity;
+        }
+
+        qreal accel = eventType == QEvent::Wheel ? wheelDeceleration : deceleration;
+        qCDebug(lcFlickable) << "choosing deceleration" << accel << "for" << eventType;
+        // adjust accel so that we hit a full pixel
+        qreal v2 = v * v;
+        qreal dist = v2 / (accel * 2.0);
+        if (v > 0)
+            dist = -dist;
+        qreal target = std::round(data.move.value() - dist);
+        dist = -target + data.move.value();
+        accel = v2 / (2.0f * qAbs(dist));
+
+        resetTimeline(data);
+        if (!data.inOvershoot) {
+            if (boundsBehavior & StretchFlickable::OvershootBounds)
+                timeline.accel(data.move, v, accel);
+            else
+                timeline.accel(data.move, v, accel, maxDistance);
+        }
+        timeline.callback(StretchTimeLineCallback(&data.move, fixupCallback, this));
+
+        if (&data == &hData)
+            return !hData.flicking && q->xflick();
+        else if (&data == &vData)
+            return !vData.flicking && q->yflick();
+        return false;
+    } else {
+        resetTimeline(data);
+        fixup(data, minExtent, maxExtent);
+        return false;
+    }
+}
+
+void StretchFlickablePrivate::fixupY_callback(void *data)
+{
+    ((StretchFlickablePrivate *)data)->fixupY();
+}
+
+void StretchFlickablePrivate::fixupX_callback(void *data)
+{
+    ((StretchFlickablePrivate *)data)->fixupX();
+}
+
+void StretchFlickablePrivate::fixupX()
+{
+    Q_Q(StretchFlickable);
+    if (!q->isComponentComplete())
+        return; //Do not fixup from initialization values
+    fixup(hData, q->minXExtent(), q->maxXExtent());
+}
+
+void StretchFlickablePrivate::fixupY()
+{
+    Q_Q(StretchFlickable);
+    if (!q->isComponentComplete())
+        return; //Do not fixup from initialization values
+    fixup(vData, q->minYExtent(), q->maxYExtent());
+}
+
+/*!
+    \internal
+
+    Adjusts the contentItem's position via the timeline.
+    This function is used by StretchFlickablePrivate::fixup in order to
+    position the contentItem back into the viewport, in case flicking,
+    dragging or geometry adjustments moved it outside of bounds.
+*/
+void StretchFlickablePrivate::adjustContentPos(AxisData &data, qreal toPos)
+{
+    Q_Q(StretchFlickable);
+    switch (fixupMode) {
+    case Immediate:
+        timeline.set(data.move, toPos);
+        break;
+    case ExtentChanged:
+        // The target has changed. Don't start from the beginning; just complete the
+        // second half of the animation using the new extent.
+        timeline.move(data.move, toPos, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
+        data.fixingUp = true;
+        break;
+    default: {
+            if (data.transitionToBounds && data.transitionToBounds->startTransition(&data, toPos)) {
+                q->movementStarting();
+                data.fixingUp = true;
+            } else {
+                qreal dist = toPos - data.move;
+                timeline.move(data.move, toPos - dist/2, QEasingCurve(QEasingCurve::InQuad), fixupDuration/4);
+                timeline.move(data.move, toPos, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);
+                data.fixingUp = true;
+            }
+        }
+    }
+}
+
+void StretchFlickablePrivate::resetTimeline(AxisData &data)
+{
+    timeline.reset(data.move);
+    if (data.transitionToBounds)
+        data.transitionToBounds->stopTransition();
+}
+
+void StretchFlickablePrivate::clearTimeline()
+{
+    timeline.clear();
+    if (hData.transitionToBounds)
+        hData.transitionToBounds->stopTransition();
+    if (vData.transitionToBounds)
+        vData.transitionToBounds->stopTransition();
+}
+
+/*!
+    \internal
+
+    This function should be called after the contentItem has been moved, either programmatically,
+    or by the timeline (as a result of a flick).
+    It ensures that the contentItem will be moved back into bounds,
+    in case it was flicked outside of the visible area.
+
+    The positional adjustment will usually be animated by the timeline, unless the fixupMode is set to Immediate.
+*/
+void StretchFlickablePrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)
+{
+    if (data.move.value() >= minExtent || maxExtent > minExtent) {
+        resetTimeline(data);
+        if (data.move.value() != minExtent) {
+            adjustContentPos(data, minExtent);
+        }
+    } else if (data.move.value() <= maxExtent) {
+        resetTimeline(data);
+        adjustContentPos(data, maxExtent);
+    } else if (-std::round(-data.move.value()) != data.move.value()) {
+        // We could animate, but since it is less than 0.5 pixel it's probably not worthwhile.
+        resetTimeline(data);
+        qreal val = data.move.value();
+        if (std::abs(std::round(val) - val) < 0.25) // round small differences
+            val = std::round(val);
+        else if (data.smoothVelocity.value() > 0) // continue direction of motion for larger
+            val = std::ceil(val);
+        else if (data.smoothVelocity.value() < 0)
+            val = std::floor(val);
+        else // otherwise round
+            val = std::round(val);
+        timeline.set(data.move, val);
+    }
+    data.inOvershoot = false;
+    fixupMode = Normal;
+    data.vTime = timeline.time();
+}
+
+static bool fuzzyLessThanOrEqualTo(qreal a, qreal b)
+{
+    if (a == 0.0 || b == 0.0) {
+        // qFuzzyCompare is broken
+        a += 1.0;
+        b += 1.0;
+    }
+    return a <= b || qFuzzyCompare(a, b);
+}
+
+/*!
+    \internal
+
+    This function's main purpose is to update the atBeginning and atEnd flags
+    in hData and vData. It should be called when the contentItem has moved,
+    to ensure that hData and vData are up to date.
+
+    The origin will also be updated, if AxisData::markExtentsDirty has been called
+*/
+void StretchFlickablePrivate::updateBeginningEnd()
+{
+    Q_Q(StretchFlickable);
+    bool atXBeginningChange = false, atXEndChange = false;
+    bool atYBeginningChange = false, atYEndChange = false;
+
+    // Vertical
+    const qreal maxyextent = -q->maxYExtent();
+    const qreal minyextent = -q->minYExtent();
+    const qreal ypos = pixelAligned ? -std::round(vData.move.value()) : -vData.move.value();
+    bool atBeginning = fuzzyLessThanOrEqualTo(ypos, std::ceil(minyextent));
+    bool atEnd = fuzzyLessThanOrEqualTo(std::floor(maxyextent), ypos);
+
+    if (atBeginning != vData.atBeginning) {
+        vData.atBeginning = atBeginning;
+        atYBeginningChange = true;
+        if (!vData.moving && atBeginning)
+            vData.smoothVelocity.setValue(0);
+    }
+    if (atEnd != vData.atEnd) {
+        vData.atEnd = atEnd;
+        atYEndChange = true;
+        if (!vData.moving && atEnd)
+            vData.smoothVelocity.setValue(0);
+    }
+
+    // Horizontal
+    const qreal maxxextent = -q->maxXExtent();
+    const qreal minxextent = -q->minXExtent();
+    const qreal xpos = pixelAligned ? -std::round(hData.move.value()) : -hData.move.value();
+    atBeginning = fuzzyLessThanOrEqualTo(xpos, std::ceil(minxextent));
+    atEnd = fuzzyLessThanOrEqualTo(std::floor(maxxextent), xpos);
+
+    if (atBeginning != hData.atBeginning) {
+        hData.atBeginning = atBeginning;
+        atXBeginningChange = true;
+        if (!hData.moving && atBeginning)
+            hData.smoothVelocity.setValue(0);
+    }
+    if (atEnd != hData.atEnd) {
+        hData.atEnd = atEnd;
+        atXEndChange = true;
+        if (!hData.moving && atEnd)
+            hData.smoothVelocity.setValue(0);
+    }
+
+    if (vData.extentsChanged) {
+        vData.extentsChanged = false;
+        qreal originY = q->originY();
+        if (vData.origin != originY) {
+            vData.origin = originY;
+            emit q->originYChanged();
+        }
+    }
+
+    if (hData.extentsChanged) {
+        hData.extentsChanged = false;
+        qreal originX = q->originX();
+        if (hData.origin != originX) {
+            hData.origin = originX;
+            emit q->originXChanged();
+        }
+    }
+
+    if (atXEndChange || atYEndChange || atXBeginningChange || atYBeginningChange)
+        emit q->isAtBoundaryChanged();
+    if (atXEndChange)
+        emit q->atXEndChanged();
+    if (atXBeginningChange)
+        emit q->atXBeginningChanged();
+    if (atYEndChange)
+        emit q->atYEndChanged();
+    if (atYBeginningChange)
+        emit q->atYBeginningChanged();
+
+    if (visibleArea)
+        visibleArea->updateVisible();
+}
+
+/*!
+    \qmlsignal QtQuick::Flickable::dragStarted()
+
+    This signal is emitted when the view starts to be dragged due to user
+    interaction.
+*/
+
+/*!
+    \qmlsignal QtQuick::Flickable::dragEnded()
+
+    This signal is emitted when the user stops dragging the view.
+
+    If the velocity of the drag is sufficient at the time the
+    touch/mouse button is released then a flick will start.
+*/
+
+/*!
+    \qmltype Flickable
+    \nativetype StretchFlickable
+    \inqmlmodule QtQuick
+    \ingroup qtquick-input
+    \ingroup qtquick-containers
+
+    \brief Provides a surface that can be "flicked".
+    \inherits Item
+
+    The Flickable item places its children on a surface that can be dragged
+    and flicked, causing the view onto the child items to scroll. This
+    behavior forms the basis of Items that are designed to show large numbers
+    of child items, such as \l ListView and \l GridView.
+
+    In traditional user interfaces, views can be scrolled using standard
+    controls, such as scroll bars and arrow buttons. In some situations, it
+    is also possible to drag the view directly by pressing and holding a
+    mouse button while moving the cursor. In touch-based user interfaces,
+    this dragging action is often complemented with a flicking action, where
+    scrolling continues after the user has stopped touching the view.
+
+    Flickable does not automatically clip its contents. If it is not used as
+    a full-screen item, you should consider setting the \l{Item::}{clip} property
+    to true.
+
+    \section1 Example Usage
+
+    \div {class="float-right"}
+    \inlineimage flickable.gif
+    \enddiv
+
+    The following example shows a small view onto a large image in which the
+    user can drag or flick the image in order to view different parts of it.
+
+    \snippet qml/flickable.qml document
+
+    \clearfloat
+
+    Items declared as children of a Flickable are automatically parented to the
+    Flickable's \l contentItem.  This should be taken into account when
+    operating on the children of the Flickable; it is usually the children of
+    \c contentItem that are relevant.  For example, the bound of Items added
+    to the Flickable will be available by \c contentItem.childrenRect
+
+    \section1 Examples of contentX and contentY
+
+    The following images demonstrate a flickable being flicked in various
+    directions and the resulting \l contentX and \l contentY values.
+    The blue square represents the flickable's content, and the black
+    border represents the bounds of the flickable.
+
+    \table
+        \row
+            \li \image flickable-contentXY-resting.png
+            \li The \c contentX and \c contentY are both \c 0.
+        \row
+            \li \image flickable-contentXY-top-left.png
+            \li The \c contentX and the \c contentY are both \c 50.
+        \row
+            \li \image flickable-contentXY-top-right.png
+            \li The \c contentX is \c -50 and the \c contentY is \c 50.
+        \row
+            \li \image flickable-contentXY-bottom-right.png
+            \li The \c contentX and the \c contentY are both \c -50.
+        \row
+            \li \image flickable-contentXY-bottom-left.png
+            \li The \c contentX is \c 50 and the \c contentY is \c -50.
+    \endtable
+
+    \section1 Limitations
+
+    \note Due to an implementation detail, items placed inside a Flickable
+    cannot anchor to the Flickable. Instead, use \l {Item::}{parent}, which
+    refers to the Flickable's \l contentItem. The size of the content item is
+    determined by \l contentWidth and \l contentHeight.
+*/
+
+/*!
+    \qmlsignal QtQuick::Flickable::movementStarted()
+
+    This signal is emitted when the view begins moving due to user
+    interaction or a generated flick().
+*/
+
+/*!
+    \qmlsignal QtQuick::Flickable::movementEnded()
+
+    This signal is emitted when the view stops moving due to user
+    interaction or a generated flick().  If a flick was active, this signal will
+    be emitted once the flick stops.  If a flick was not
+    active, this signal will be emitted when the
+    user stops dragging - i.e. a mouse or touch release.
+*/
+
+/*!
+    \qmlsignal QtQuick::Flickable::flickStarted()
+
+    This signal is emitted when the view is flicked.  A flick
+    starts from the point that the mouse or touch is released,
+    while still in motion.
+*/
+
+/*!
+    \qmlsignal QtQuick::Flickable::flickEnded()
+
+    This signal is emitted when the view stops moving after a flick
+    or a series of flicks.
+*/
+
+/*!
+    \qmlpropertygroup QtQuick::Flickable::visibleArea
+    \qmlproperty real QtQuick::Flickable::visibleArea.xPosition
+    \qmlproperty real QtQuick::Flickable::visibleArea.widthRatio
+    \qmlproperty real QtQuick::Flickable::visibleArea.yPosition
+    \qmlproperty real QtQuick::Flickable::visibleArea.heightRatio
+
+    These properties describe the position and size of the currently viewed area.
+    The size is defined as the percentage of the full view currently visible,
+    scaled to 0.0 - 1.0.  The page position is usually in the range 0.0 (beginning) to
+    1.0 minus size ratio (end), i.e. \c yPosition is in the range 0.0 to 1.0-\c heightRatio.
+    However, it is possible for the contents to be dragged outside of the normal
+    range, resulting in the page positions also being outside the normal range.
+
+    These properties are typically used to draw a scrollbar. For example:
+
+    \snippet qml/flickableScrollbar.qml 0
+    \dots 8
+    \snippet qml/flickableScrollbar.qml 1
+*/
+StretchFlickable::StretchFlickable(QQuickItem *parent)
+  : QQuickItem(*(new StretchFlickablePrivate), parent)
+{
+    Q_D(StretchFlickable);
+    d->init();
+}
+
+StretchFlickable::StretchFlickable(StretchFlickablePrivate &dd, QQuickItem *parent)
+  : QQuickItem(dd, parent)
+{
+    Q_D(StretchFlickable);
+    d->init();
+}
+
+StretchFlickable::~StretchFlickable()
+{
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::contentX
+    \qmlproperty real QtQuick::Flickable::contentY
+
+    These properties hold the surface coordinate currently at the top-left
+    corner of the Flickable. For example, if you flick an image up 100 pixels,
+    \c contentY will increase by 100.
+
+    \note If you flick back to the origin (the top-left corner), after the
+    rebound animation, \c contentX will settle to the same value as \c originX,
+    and \c contentY to \c originY. These are usually (0,0), however ListView
+    and GridView may have an arbitrary origin due to delegate size variation,
+    or item insertion/removal outside the visible region. So if you want to
+    implement something like a vertical scrollbar, one way is to use
+    \c {y: (contentY - originY) * (height / contentHeight)}
+    for the position; another way is to use the normalized values in
+    \l {QtQuick::Flickable::visibleArea}{visibleArea}.
+
+    \sa {Examples of contentX and contentY}, originX, originY
+*/
+qreal StretchFlickable::contentX() const
+{
+    Q_D(const StretchFlickable);
+    return -d->contentItem->x();
+}
+
+void StretchFlickable::setContentX(qreal pos)
+{
+    Q_D(StretchFlickable);
+    d->hData.explicitValue = true;
+    d->resetTimeline(d->hData);
+    d->hData.vTime = d->timeline.time();
+    if (isMoving() || isFlicking())
+        movementEnding(true, false);
+    if (!qFuzzyCompare(-pos, d->hData.move.value())) {
+        d->hData.contentPositionChangedExternallyDuringDrag = d->hData.dragging;
+        d->hData.move.setValue(-pos);
+        d->hData.contentPositionChangedExternallyDuringDrag = false;
+    }
+}
+
+qreal StretchFlickable::contentY() const
+{
+    Q_D(const StretchFlickable);
+    return -d->contentItem->y();
+}
+
+void StretchFlickable::setContentY(qreal pos)
+{
+    Q_D(StretchFlickable);
+    d->vData.explicitValue = true;
+    d->resetTimeline(d->vData);
+    d->vData.vTime = d->timeline.time();
+    if (isMoving() || isFlicking())
+        movementEnding(false, true);
+    if (!qFuzzyCompare(-pos, d->vData.move.value())) {
+        d->vData.contentPositionChangedExternallyDuringDrag = d->vData.dragging;
+        d->vData.move.setValue(-pos);
+        d->vData.contentPositionChangedExternallyDuringDrag = false;
+    }
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::interactive
+
+    This property describes whether the user can interact with the Flickable.
+    A user cannot drag or flick a Flickable that is not interactive.
+
+    By default, this property is true.
+
+    This property is useful for temporarily disabling flicking. This allows
+    special interaction with Flickable's children; for example, you might want
+    to freeze a flickable map while scrolling through a pop-up dialog that
+    is a child of the Flickable.
+*/
+bool StretchFlickable::isInteractive() const
+{
+    Q_D(const StretchFlickable);
+    return d->interactive;
+}
+
+void StretchFlickable::setInteractive(bool interactive)
+{
+    Q_D(StretchFlickable);
+    if (interactive != d->interactive) {
+        d->interactive = interactive;
+        if (!interactive) {
+            d->cancelInteraction();
+        }
+        emit interactiveChanged();
+    }
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::horizontalVelocity
+    \qmlproperty real QtQuick::Flickable::verticalVelocity
+
+    The instantaneous velocity of movement along the x and y axes, in pixels/sec.
+
+    The reported velocity is smoothed to avoid erratic output.
+
+    Note that for views with a large content size (more than 10 times the view size),
+    the velocity of the flick may exceed the velocity of the touch in the case
+    of multiple quick consecutive flicks.  This allows the user to flick faster
+    through large content.
+*/
+qreal StretchFlickable::horizontalVelocity() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.smoothVelocity.value();
+}
+
+qreal StretchFlickable::verticalVelocity() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.smoothVelocity.value();
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::atXBeginning
+    \qmlproperty bool QtQuick::Flickable::atXEnd
+    \qmlproperty bool QtQuick::Flickable::atYBeginning
+    \qmlproperty bool QtQuick::Flickable::atYEnd
+
+    These properties are true if the flickable view is positioned at the beginning,
+    or end respectively.
+*/
+bool StretchFlickable::isAtXEnd() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.atEnd;
+}
+
+bool StretchFlickable::isAtXBeginning() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.atBeginning;
+}
+
+bool StretchFlickable::isAtYEnd() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.atEnd;
+}
+
+bool StretchFlickable::isAtYBeginning() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.atBeginning;
+}
+
+/*!
+    \qmlproperty Item QtQuick::Flickable::contentItem
+
+    The internal item that contains the Items to be moved in the Flickable.
+
+    Items declared as children of a Flickable are automatically parented to the Flickable's contentItem.
+
+    Items created dynamically need to be explicitly parented to the \e contentItem:
+    \code
+    Flickable {
+        id: myFlickable
+        function addItem(file) {
+            var component = Qt.createComponent(file)
+            component.createObject(myFlickable.contentItem);
+        }
+    }
+    \endcode
+*/
+QQuickItem *StretchFlickable::contentItem() const
+{
+    Q_D(const StretchFlickable);
+    return d->contentItem;
+}
+
+StretchFlickableVisibleArea *StretchFlickable::visibleArea()
+{
+    Q_D(StretchFlickable);
+    if (!d->visibleArea) {
+        d->visibleArea = new StretchFlickableVisibleArea(this);
+        d->visibleArea->updateVisible(); // calculate initial ratios
+    }
+    return d->visibleArea;
+}
+
+/*!
+    \qmlproperty enumeration QtQuick::Flickable::flickableDirection
+
+    This property determines which directions the view can be flicked.
+
+    \list
+    \li Flickable.AutoFlickDirection (default) - allows flicking vertically if the
+    \e contentHeight is not equal to the \e height of the Flickable.
+    Allows flicking horizontally if the \e contentWidth is not equal
+    to the \e width of the Flickable.
+    \li Flickable.AutoFlickIfNeeded - allows flicking vertically if the
+    \e contentHeight is greater than the \e height of the Flickable.
+    Allows flicking horizontally if the \e contentWidth is greater than
+    to the \e width of the Flickable. (since \c{QtQuick 2.7})
+    \li Flickable.HorizontalFlick - allows flicking horizontally.
+    \li Flickable.VerticalFlick - allows flicking vertically.
+    \li Flickable.HorizontalAndVerticalFlick - allows flicking in both directions.
+    \endlist
+*/
+StretchFlickable::FlickableDirection StretchFlickable::flickableDirection() const
+{
+    Q_D(const StretchFlickable);
+    return d->flickableDirection;
+}
+
+void StretchFlickable::setFlickableDirection(FlickableDirection direction)
+{
+    Q_D(StretchFlickable);
+    if (direction != d->flickableDirection) {
+        d->flickableDirection = direction;
+        emit flickableDirectionChanged();
+    }
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::pixelAligned
+
+    This property sets the alignment of \l contentX and \l contentY to
+    pixels (\c true) or subpixels (\c false).
+
+    Enable pixelAligned to optimize for still content or moving content with
+    high constrast edges, such as one-pixel-wide lines, text or vector graphics.
+    Disable pixelAligned when optimizing for animation quality.
+
+    The default is \c false.
+*/
+bool StretchFlickable::pixelAligned() const
+{
+    Q_D(const StretchFlickable);
+    return d->pixelAligned;
+}
+
+void StretchFlickable::setPixelAligned(bool align)
+{
+    Q_D(StretchFlickable);
+    if (align != d->pixelAligned) {
+        d->pixelAligned = align;
+        emit pixelAlignedChanged();
+    }
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::synchronousDrag
+    \since 5.12
+
+    If this property is set to true, then when the mouse or touchpoint moves
+    far enough to begin dragging the content, the content will jump, such that
+    the content pixel which was under the cursor or touchpoint when pressed
+    remains under that point.
+
+    The default is \c false, which provides a smoother experience (no jump)
+    at the cost that some of the drag distance is "lost" at the beginning.
+*/
+bool StretchFlickable::synchronousDrag() const
+{
+    Q_D(const StretchFlickable);
+    return d->syncDrag;
+}
+
+void StretchFlickable::setSynchronousDrag(bool v)
+{
+    Q_D(StretchFlickable);
+    if (v != d->syncDrag) {
+        d->syncDrag = v;
+        emit synchronousDragChanged();
+    }
+}
+
+/*!
+    \qmlproperty flags QtQuick::Flickable::acceptedButtons
+    \since 6.9
+
+    The mouse buttons that can be used to scroll this Flickable by dragging.
+
+    By default, this property is set to \l {QtQuick::MouseEvent::button} {Qt.LeftButton},
+    which provides the same behavior as in previous Qt versions; but in most
+    user interfaces, this behavior is unexpected. Users expect to flick only on
+    a touchscreen, and to use the mouse wheel, touchpad gestures or a scroll
+    bar with mouse or touchpad. Set it to \c Qt.NoButton to disable dragging.
+
+    It can be set to an OR combination of mouse buttons, and will ignore events
+    from other buttons.
+*/
+Qt::MouseButtons StretchFlickable::acceptedButtons() const
+{
+    Q_D(const StretchFlickable);
+    return d->acceptedButtons;
+}
+
+void StretchFlickable::setAcceptedButtons(Qt::MouseButtons buttons)
+{
+    Q_D(StretchFlickable);
+    if (d->acceptedButtons == buttons)
+        return;
+
+    d->acceptedButtons = buttons;
+    setAcceptedMouseButtons(buttons);
+    emit acceptedButtonsChanged();
+}
+
+/*! \internal
+    Take the velocity of the first point from the given \a event and transform
+    it to the local coordinate system (taking scale and rotation into account).
+*/
+QVector2D StretchFlickablePrivate::firstPointLocalVelocity(QPointerEvent *event)
+{
+    QTransform transform = windowToItemTransform();
+    // rotate and scale the velocity vector from scene to local
+    return QVector2D(transform.map(event->point(0).velocity().toPointF()) - transform.map(QPointF()));
+}
+
+qint64 StretchFlickablePrivate::computeCurrentTime(QInputEvent *event) const
+{
+    if (0 != event->timestamp())
+        return event->timestamp();
+    if (!timer.isValid())
+        return 0LL;
+    return timer.elapsed();
+}
+
+qreal StretchFlickablePrivate::devicePixelRatio() const
+{
+    return (window ? window->effectiveDevicePixelRatio() : qApp->devicePixelRatio());
+}
+
+void StretchFlickablePrivate::handlePressEvent(QPointerEvent *event)
+{
+    Q_Q(StretchFlickable);
+    timer.start();
+    if (interactive && timeline.isActive()
+        && ((qAbs(hData.smoothVelocity.value()) > RetainGrabVelocity && !hData.fixingUp && !hData.inOvershoot)
+            || (qAbs(vData.smoothVelocity.value()) > RetainGrabVelocity && !vData.fixingUp && !vData.inOvershoot))) {
+        stealMouse = true; // If we've been flicked then steal the click.
+        int flickTime = timeline.time();
+        if (flickTime > 600) {
+            // too long between flicks - cancel boost
+            hData.continuousFlickVelocity = 0;
+            vData.continuousFlickVelocity = 0;
+            flickBoost = 1.0;
+        } else {
+            hData.continuousFlickVelocity = -hData.smoothVelocity.value();
+            vData.continuousFlickVelocity = -vData.smoothVelocity.value();
+            if (flickTime > 300) // slower flicking - reduce boost
+                flickBoost = qMax(1.0, flickBoost - 0.5);
+        }
+    } else {
+        stealMouse = false;
+        hData.continuousFlickVelocity = 0;
+        vData.continuousFlickVelocity = 0;
+        flickBoost = 1.0;
+    }
+    q->setKeepMouseGrab(stealMouse);
+
+    maybeBeginDrag(computeCurrentTime(event), event->points().first().position(),
+                   event->isSinglePointEvent() ? static_cast<QSinglePointEvent *>(event)->buttons()
+                                               : Qt::NoButton);
+}
+
+void StretchFlickablePrivate::maybeBeginDrag(qint64 currentTimestamp, const QPointF &pressPosn, Qt::MouseButtons buttons)
+{
+    Q_Q(StretchFlickable);
+    clearDelayedPress();
+    // consider dragging only when buttons intersect acceptedButtons, or it's a touch event which has no button
+    pressed = (buttons == Qt::NoButton) || (acceptedButtons != Qt::NoButton && (buttons & acceptedButtons) != 0);
+
+    if (hData.transitionToBounds)
+        hData.transitionToBounds->stopTransition();
+    if (vData.transitionToBounds)
+        vData.transitionToBounds->stopTransition();
+    if (!hData.fixingUp)
+        resetTimeline(hData);
+    if (!vData.fixingUp)
+        resetTimeline(vData);
+
+    hData.reset();
+    vData.reset();
+    hData.dragMinBound = q->minXExtent() - hData.startMargin;
+    vData.dragMinBound = q->minYExtent() - vData.startMargin;
+    hData.dragMaxBound = q->maxXExtent() + hData.endMargin;
+    vData.dragMaxBound = q->maxYExtent() + vData.endMargin;
+    fixupMode = Normal;
+    lastPos = QPointF();
+    pressPos = pressPosn;
+    hData.pressPos = hData.move.value();
+    vData.pressPos = vData.move.value();
+    const bool wasFlicking = hData.flicking || vData.flicking;
+    hData.flickingWhenDragBegan = hData.flicking;
+    vData.flickingWhenDragBegan = vData.flicking;
+    if (hData.flicking) {
+        hData.flicking = false;
+        emit q->flickingHorizontallyChanged();
+    }
+    if (vData.flicking) {
+        vData.flicking = false;
+        emit q->flickingVerticallyChanged();
+    }
+    if (wasFlicking)
+        emit q->flickingChanged();
+    lastPosTime = lastPressTime = currentTimestamp;
+    vData.velocityTime.start();
+    hData.velocityTime.start();
+}
+
+void StretchFlickablePrivate::drag(qint64 currentTimestamp, QEvent::Type eventType, const QPointF &localPos,
+                                  const QVector2D &deltas, bool overThreshold, bool momentum,
+                                  bool velocitySensitiveOverBounds, const QVector2D &velocity)
+{
+    Q_Q(StretchFlickable);
+    bool rejectY = false;
+    bool rejectX = false;
+
+    bool keepY = q->yflick();
+    bool keepX = q->xflick();
+
+    bool stealY = false;
+    bool stealX = false;
+    if (eventType == QEvent::MouseMove) {
+        stealX = stealY = stealMouse;
+    } else if (eventType == QEvent::Wheel) {
+        stealX = stealY = scrollingPhase;
+    }
+
+    bool prevHMoved = hMoved;
+    bool prevVMoved = vMoved;
+
+    qint64 elapsedSincePress = currentTimestamp - lastPressTime;
+    qCDebug(lcFlickable).nospace() << currentTimestamp << ' ' << eventType << " drag @ " << localPos.x() << ',' << localPos.y()
+                                   << " \u0394 " << deltas.x() << ',' << deltas.y() << " vel " << velocity.x() << ',' << velocity.y()
+                                   << " thrsld? " << overThreshold << " momentum? " << momentum << " velSens? " << velocitySensitiveOverBounds
+                                   << " sincePress " << elapsedSincePress;
+
+    if (q->yflick()) {
+        qreal dy = deltas.y();
+        if (overThreshold || elapsedSincePress > 200) {
+            if (!vMoved)
+                vData.dragStartOffset = dy;
+            qreal newY = dy + vData.pressPos - (syncDrag ? 0 : vData.dragStartOffset);
+            // Recalculate bounds in case margins have changed, but use the content
+            // size estimate taken at the start of the drag in case the drag causes
+            // the estimate to be altered
+            const qreal minY = vData.dragMinBound + vData.startMargin;
+            const qreal maxY = vData.dragMaxBound - vData.endMargin;
+            if (!(boundsBehavior & StretchFlickable::DragOverBounds)) {
+                if (fuzzyLessThanOrEqualTo(newY, maxY)) {
+                    newY = maxY;
+                    rejectY = vData.pressPos == maxY && vData.move.value() == maxY && dy < 0;
+                }
+                if (fuzzyLessThanOrEqualTo(minY, newY)) {
+                    newY = minY;
+                    rejectY |= vData.pressPos == minY && vData.move.value() == minY && dy > 0;
+                }
+            } else {
+                qreal vel = velocity.y() / QML_FLICK_OVERSHOOTFRICTION;
+                if (vel > 0. && vel > vData.velocity)
+                    vData.velocity = qMin(velocity.y() / QML_FLICK_OVERSHOOTFRICTION, maxVelocity);
+                else if (vel < 0. && vel < vData.velocity)
+                    vData.velocity = qMax(velocity.y() / QML_FLICK_OVERSHOOTFRICTION, -maxVelocity);
+                if (newY > minY) {
+                    // Overshoot beyond the top.  But don't wait for momentum phase to end before returning to bounds.
+                    if (momentum && vData.atBeginning) {
+                        if (!vData.inRebound) {
+                            vData.inRebound = true;
+                            q->returnToBounds();
+                        }
+                        return;
+                    }
+                    if (velocitySensitiveOverBounds) {
+                        qreal overshoot = (newY - minY) * vData.velocity / maxVelocity / QML_FLICK_OVERSHOOTFRICTION;
+                        overshoot = QML_FLICK_OVERSHOOT * devicePixelRatio() * EaseOvershoot(overshoot / QML_FLICK_OVERSHOOT / devicePixelRatio());
+                        newY = minY + overshoot;
+                    } else {
+                        // Progressive drag-over-bounds resistance: small
+                        // overshoots track the finger closely, larger ones
+                        // increasingly resist, asymptoting at dragOvershootMax
+                        // (never sliding past it) - see dragResistanceCurve().
+                        qreal overshoot = newY - minY;
+                        overshoot = dragResistanceCurve(overshoot, dragOvershootRange(), dragOvershootMaxPixels());
+                        newY = minY + overshoot;
+                    }
+                } else if (newY < maxY && maxY - minY <= 0) {
+                    // Overshoot beyond the bottom.  But don't wait for momentum phase to end before returning to bounds.
+                    if (momentum && vData.atEnd) {
+                        if (!vData.inRebound) {
+                            vData.inRebound = true;
+                            q->returnToBounds();
+                        }
+                        return;
+                    }
+                    if (velocitySensitiveOverBounds) {
+                        qreal overshoot = (newY - maxY) * vData.velocity / maxVelocity / QML_FLICK_OVERSHOOTFRICTION;
+                        overshoot = QML_FLICK_OVERSHOOT * devicePixelRatio() * EaseOvershoot(overshoot / QML_FLICK_OVERSHOOT / devicePixelRatio());
+                        newY = maxY - overshoot;
+                    } else {
+                        qreal overshoot = newY - maxY;
+                        overshoot = dragResistanceCurve(overshoot, dragOvershootRange(), dragOvershootMaxPixels());
+                        newY = maxY + overshoot;
+                    }
+                }
+            }
+            if (!rejectY && stealMouse && dy != vData.previousDragDelta) {
+                clearTimeline();
+                vData.move.setValue(newY);
+                vMoved = true;
+            }
+            if (!rejectY && overThreshold)
+                stealY = true;
+
+            if ((newY >= minY && vData.pressPos == minY && vData.move.value() == minY && dy > 0)
+                        || (newY <= maxY && vData.pressPos == maxY && vData.move.value() == maxY && dy < 0)) {
+                keepY = false;
+            }
+        }
+        vData.previousDragDelta = dy;
+    }
+
+    if (q->xflick()) {
+        qreal dx = deltas.x();
+        if (overThreshold || elapsedSincePress > 200) {
+            if (!hMoved)
+                hData.dragStartOffset = dx;
+            qreal newX = dx + hData.pressPos - (syncDrag ? 0 : hData.dragStartOffset);
+            const qreal minX = hData.dragMinBound + hData.startMargin;
+            const qreal maxX = hData.dragMaxBound - hData.endMargin;
+            if (!(boundsBehavior & StretchFlickable::DragOverBounds)) {
+                if (fuzzyLessThanOrEqualTo(newX, maxX)) {
+                    newX = maxX;
+                    rejectX = hData.pressPos == maxX && hData.move.value() == maxX && dx < 0;
+                }
+                if (fuzzyLessThanOrEqualTo(minX, newX)) {
+                    newX = minX;
+                    rejectX |= hData.pressPos == minX && hData.move.value() == minX && dx > 0;
+                }
+            } else {
+                qreal vel = velocity.x() / QML_FLICK_OVERSHOOTFRICTION;
+                if (vel > 0. && vel > hData.velocity)
+                    hData.velocity = qMin(velocity.x() / QML_FLICK_OVERSHOOTFRICTION, maxVelocity);
+                else if (vel < 0. && vel < hData.velocity)
+                    hData.velocity = qMax(velocity.x() / QML_FLICK_OVERSHOOTFRICTION, -maxVelocity);
+                if (newX > minX) {
+                    // Overshoot beyond the left.  But don't wait for momentum phase to end before returning to bounds.
+                    if (momentum && hData.atBeginning) {
+                        if (!hData.inRebound) {
+                            hData.inRebound = true;
+                            q->returnToBounds();
+                        }
+                        return;
+                    }
+                    if (velocitySensitiveOverBounds) {
+                        qreal overshoot = (newX - minX) * hData.velocity / maxVelocity / QML_FLICK_OVERSHOOTFRICTION;
+                        overshoot = QML_FLICK_OVERSHOOT * devicePixelRatio() * EaseOvershoot(overshoot / QML_FLICK_OVERSHOOT / devicePixelRatio());
+                        newX = minX + overshoot;
+                    } else {
+                        qreal overshoot = newX - minX;
+                        overshoot = dragResistanceCurve(overshoot, dragOvershootRange(), dragOvershootMaxPixels());
+                        newX = minX + overshoot;
+                    }
+                } else if (newX < maxX && maxX - minX <= 0) {
+                    // Overshoot beyond the right.  But don't wait for momentum phase to end before returning to bounds.
+                    if (momentum && hData.atEnd) {
+                        if (!hData.inRebound) {
+                            hData.inRebound = true;
+                            q->returnToBounds();
+                        }
+                        return;
+                    }
+                    if (velocitySensitiveOverBounds) {
+                        qreal overshoot = (newX - maxX) * hData.velocity / maxVelocity / QML_FLICK_OVERSHOOTFRICTION;
+                        overshoot = QML_FLICK_OVERSHOOT * devicePixelRatio() * EaseOvershoot(overshoot / QML_FLICK_OVERSHOOT / devicePixelRatio());
+                        newX = maxX - overshoot;
+                    } else {
+                        qreal overshoot = newX - maxX;
+                        overshoot = dragResistanceCurve(overshoot, dragOvershootRange(), dragOvershootMaxPixels());
+                        newX = maxX + overshoot;
+                    }
+                }
+            }
+            if (!rejectX && stealMouse && dx != hData.previousDragDelta) {
+                clearTimeline();
+                hData.move.setValue(newX);
+                hMoved = true;
+            }
+
+            if (!rejectX && overThreshold)
+                stealX = true;
+
+            if ((newX >= minX && vData.pressPos == minX && vData.move.value() == minX && dx > 0)
+                        || (newX <= maxX && vData.pressPos == maxX && vData.move.value() == maxX && dx < 0)) {
+                keepX = false;
+            }
+        }
+        hData.previousDragDelta = dx;
+    }
+
+    stealMouse = stealX || stealY;
+    if (stealMouse) {
+        if ((stealX && keepX) || (stealY && keepY))
+            q->setKeepMouseGrab(true);
+        clearDelayedPress();
+    }
+
+    if (rejectY) {
+        vData.velocityBuffer.clear();
+        vData.velocity = 0;
+    }
+    if (rejectX) {
+        hData.velocityBuffer.clear();
+        hData.velocity = 0;
+    }
+
+    if (momentum && !hData.flicking && !vData.flicking)
+        flickingStarted(hData.velocity != 0, vData.velocity != 0);
+    draggingStarting();
+
+    if ((hMoved && !prevHMoved) || (vMoved && !prevVMoved))
+        q->movementStarting();
+
+    lastPosTime = currentTimestamp;
+    if (q->yflick() && !rejectY)
+        vData.addVelocitySample(velocity.y(), maxVelocity);
+    if (q->xflick() && !rejectX)
+        hData.addVelocitySample(velocity.x(), maxVelocity);
+    lastPos = localPos;
+}
+
+void StretchFlickablePrivate::handleMoveEvent(QPointerEvent *event)
+{
+    Q_Q(StretchFlickable);
+    if (!interactive || lastPosTime == -1 ||
+            (event->isSinglePointEvent() && !buttonsAccepted(static_cast<QSinglePointEvent *>(event))))
+        return;
+
+    qint64 currentTimestamp = computeCurrentTime(event);
+    const auto &firstPoint = event->points().first();
+    const auto &pos = firstPoint.position();
+    const QVector2D deltas = QVector2D(pos - q->mapFromGlobal(firstPoint.globalPressPosition()));
+    const QVector2D velocity = firstPointLocalVelocity(event);
+    bool overThreshold = false;
+
+    if (q->isMoving()) {
+        /*
+            Only the first drag should be used to determine if the Flickable should start moving,
+            to the exclusion of some inner Control (such as Slider) or a child Flickable.
+            If the user releases the mouse or finger and drags again, this Flickable is the only
+            sensible recipient as long as it's still moving.
+            We also only care about the drag threshold for the first drag. If it's already moving,
+            every subsequent move event (however small) should move the content item immediately.
+        */
+        overThreshold = true;
+    } else if (event->pointCount() == 1) {
+        if (q->yflick())
+            overThreshold |= QQuickDeliveryAgentPrivate::dragOverThreshold(deltas.y(), Qt::YAxis, firstPoint);
+        if (q->xflick())
+            overThreshold |= QQuickDeliveryAgentPrivate::dragOverThreshold(deltas.x(), Qt::XAxis, firstPoint);
+    } else {
+        qCDebug(lcFilter) << q->objectName() << "ignoring multi-touch" << event;
+    }
+
+    drag(currentTimestamp, event->type(), pos, deltas, overThreshold, false, false, velocity);
+}
+
+void StretchFlickablePrivate::handleReleaseEvent(QPointerEvent *event)
+{
+    Q_Q(StretchFlickable);
+    stealMouse = false;
+    q->setKeepMouseGrab(false);
+    pressed = false;
+
+    // if we drag then pause before release we should not cause a flick.
+    qint64 elapsed = computeCurrentTime(event) - lastPosTime;
+
+    vData.updateVelocity();
+    hData.updateVelocity();
+
+    draggingEnding();
+
+    if (lastPosTime == -1)
+        return;
+
+    hData.vTime = vData.vTime = timeline.time();
+
+    bool canBoost = false;
+    const auto pos = event->points().first().position();
+    const auto pressPos = q->mapFromGlobal(event->points().first().globalPressPosition());
+    const QVector2D eventVelocity = firstPointLocalVelocity(event);
+    qCDebug(lcVel) << event->deviceType() << event->type() << "velocity" << event->points().first().velocity() << "transformed to local" << eventVelocity;
+
+    qreal vVelocity = 0;
+    if (elapsed < 100 && vData.velocity != 0.) {
+        vVelocity = (event->device()->capabilities().testFlag(QInputDevice::Capability::Velocity)
+                ? eventVelocity.y() : vData.velocity);
+    }
+    if ((vData.atBeginning && vVelocity > 0.) || (vData.atEnd && vVelocity < 0.)) {
+        vVelocity /= 2;
+    } else if (vData.continuousFlickVelocity != 0.0
+               && vData.viewSize/q->height() > QML_FLICK_MULTIFLICK_RATIO
+               && ((vVelocity > 0) == (vData.continuousFlickVelocity > 0))
+               && qAbs(vVelocity) > QML_FLICK_MULTIFLICK_THRESHOLD) {
+        // accelerate flick for large view flicked quickly
+        canBoost = true;
+    }
+
+    qreal hVelocity = 0;
+    if (elapsed < 100 && hData.velocity != 0.) {
+        hVelocity = (event->device()->capabilities().testFlag(QInputDevice::Capability::Velocity)
+                     ? eventVelocity.x() : hData.velocity);
+    }
+    if ((hData.atBeginning && hVelocity > 0.) || (hData.atEnd && hVelocity < 0.)) {
+        hVelocity /= 2;
+    } else if (hData.continuousFlickVelocity != 0.0
+               && hData.viewSize/q->width() > QML_FLICK_MULTIFLICK_RATIO
+               && ((hVelocity > 0) == (hData.continuousFlickVelocity > 0))
+               && qAbs(hVelocity) > QML_FLICK_MULTIFLICK_THRESHOLD) {
+        // accelerate flick for large view flicked quickly
+        canBoost = true;
+    }
+
+    flickBoost = canBoost ? qBound(1.0, flickBoost+0.25, QML_FLICK_MULTIFLICK_MAXBOOST) : 1.0;
+    const int flickThreshold = QGuiApplicationPrivate::platformTheme()->themeHint(QPlatformTheme::FlickStartDistance).toInt();
+
+    bool anyPointGrabbed = event->points().constEnd() !=
+            std::find_if(event->points().constBegin(),event->points().constEnd(),
+                [q, event](const QEventPoint &point) { return event->exclusiveGrabber(point) == q; });
+
+    bool flickedVertically = false;
+    vVelocity *= flickBoost;
+    const bool isVerticalFlickAllowed = anyPointGrabbed &&
+            q->yflick() && qAbs(vVelocity) > _q_MinimumFlickVelocity &&
+            qAbs(pos.y() - pressPos.y()) > flickThreshold;
+    if (isVerticalFlickAllowed) {
+        velocityTimeline.reset(vData.smoothVelocity);
+        vData.smoothVelocity.setValue(-vVelocity);
+        flickedVertically = flickY(event->type(), vVelocity);
+    }
+
+    bool flickedHorizontally = false;
+    hVelocity *= flickBoost;
+    const bool isHorizontalFlickAllowed = anyPointGrabbed &&
+            q->xflick() && qAbs(hVelocity) > _q_MinimumFlickVelocity &&
+            qAbs(pos.x() - pressPos.x()) > flickThreshold;
+    if (isHorizontalFlickAllowed) {
+        velocityTimeline.reset(hData.smoothVelocity);
+        hData.smoothVelocity.setValue(-hVelocity);
+        flickedHorizontally = flickX(event->type(), hVelocity);
+    }
+
+    if (!isVerticalFlickAllowed)
+        fixupY();
+
+    if (!isHorizontalFlickAllowed)
+        fixupX();
+
+    flickingStarted(flickedHorizontally, flickedVertically);
+    if (!isViewMoving()) {
+        q->movementEnding();
+    } else {
+        if (flickedVertically)
+            vMoved = true;
+        if (flickedHorizontally)
+            hMoved = true;
+        q->movementStarting();
+    }
+}
+
+bool StretchFlickablePrivate::buttonsAccepted(const QSinglePointEvent *event)
+{
+    return !((event->button() & acceptedButtons) == 0 && (event->buttons() & acceptedButtons) == 0);
+}
+
+void StretchFlickable::mousePressEvent(QMouseEvent *event)
+{
+    Q_D(StretchFlickable);
+    if (d->interactive && !d->replayingPressEvent && d->buttonsAccepted(event) && d->wantsPointerEvent(event)) {
+        if (!d->pressed)
+            d->handlePressEvent(event);
+        event->accept();
+    } else {
+        QQuickItem::mousePressEvent(event);
+    }
+}
+
+void StretchFlickable::mouseMoveEvent(QMouseEvent *event)
+{
+    Q_D(StretchFlickable);
+    if (d->interactive && d->buttonsAccepted(event) && d->wantsPointerEvent(event)) {
+        d->handleMoveEvent(event);
+        event->accept();
+    } else {
+        QQuickItem::mouseMoveEvent(event);
+    }
+}
+
+void StretchFlickable::mouseReleaseEvent(QMouseEvent *event)
+{
+    Q_D(StretchFlickable);
+    if (d->interactive && d->buttonsAccepted(event) && d->wantsPointerEvent(event)) {
+        if (d->delayedPressEvent) {
+            d->replayDelayedPress();
+
+            auto &firstPoint = event->point(0);
+            if (const auto *grabber = event->exclusiveGrabber(firstPoint); grabber && grabber->isQuickItemType()) {
+                // Since we sent the delayed press to the window, we need to resend the release to the window too.
+                // We're not copying or detaching, so restore the original event position afterwards.
+                const auto oldPosition = firstPoint.position();
+                QMutableEventPoint::setPosition(firstPoint, event->scenePosition());
+                QCoreApplication::sendEvent(window(), event);
+                QMutableEventPoint::setPosition(firstPoint, oldPosition);
+            }
+
+            // And the event has been consumed
+            d->stealMouse = false;
+            d->pressed = false;
+            return;
+        }
+
+        d->handleReleaseEvent(event);
+        event->accept();
+    } else {
+        QQuickItem::mouseReleaseEvent(event);
+    }
+}
+
+void StretchFlickable::touchEvent(QTouchEvent *event)
+{
+    Q_D(StretchFlickable);
+
+    if (event->type() == QEvent::TouchCancel) {
+        if (d->interactive && d->wantsPointerEvent(event))
+            d->cancelInteraction();
+        else
+            QQuickItem::touchEvent(event);
+        return;
+    }
+
+    bool unhandled = false;
+    const auto &firstPoint = event->points().first();
+    switch (firstPoint.state()) {
+    case QEventPoint::State::Pressed:
+        if (d->interactive && !d->replayingPressEvent && d->wantsPointerEvent(event)) {
+            if (!d->pressed)
+                d->handlePressEvent(event);
+            event->accept();
+        } else {
+            unhandled = true;
+        }
+        break;
+    case QEventPoint::State::Updated:
+        if (d->interactive && d->wantsPointerEvent(event)) {
+            d->handleMoveEvent(event);
+            event->accept();
+        } else {
+            unhandled = true;
+        }
+        break;
+    case QEventPoint::State::Released:
+        if (d->interactive && d->wantsPointerEvent(event)) {
+            if (d->delayedPressEvent) {
+                d->replayDelayedPress();
+
+                const auto &firstPoint = event->point(0);
+                if (const auto *grabber = event->exclusiveGrabber(firstPoint); grabber && grabber->isQuickItemType()) {
+                    // Since we sent the delayed press to the window, we need to resend the release to the window too.
+                    QScopedPointer<QPointerEvent> localizedEvent(
+                            QQuickDeliveryAgentPrivate::clonePointerEvent(event, firstPoint.scenePosition()));
+                    QCoreApplication::sendEvent(window(), localizedEvent.data());
+                }
+
+                // And the event has been consumed
+                d->stealMouse = false;
+                d->pressed = false;
+                return;
+            }
+
+            d->handleReleaseEvent(event);
+            event->accept();
+        } else {
+            unhandled = true;
+        }
+        break;
+    case QEventPoint::State::Stationary:
+    case QEventPoint::State::Unknown:
+        break;
+    }
+    if (unhandled)
+        QQuickItem::touchEvent(event);
+}
+
+#if QT_CONFIG(wheelevent)
+void StretchFlickable::wheelEvent(QWheelEvent *event)
+{
+    Q_D(StretchFlickable);
+    if (!d->interactive || !d->wantsPointerEvent(event)) {
+        QQuickItem::wheelEvent(event);
+        return;
+    }
+    qCDebug(lcWheel) << event->device() << event << event->source();
+    event->setAccepted(false);
+    qint64 currentTimestamp = d->computeCurrentTime(event);
+    switch (event->phase()) {
+    case Qt::ScrollBegin:
+        d->scrollingPhase = true;
+        d->accumulatedWheelPixelDelta = QVector2D();
+        d->vData.velocity = 0;
+        d->hData.velocity = 0;
+        d->timer.start();
+        d->maybeBeginDrag(currentTimestamp, event->position());
+        d->lastPosTime = -1;
+        break;
+    case Qt::NoScrollPhase: // default phase with an ordinary wheel mouse
+    case Qt::ScrollUpdate:
+        if (d->scrollingPhase)
+            d->pressed = true;
+        break;
+    case Qt::ScrollMomentum:
+        d->pressed = false;
+        d->scrollingPhase = false;
+        d->draggingEnding();
+        if (isMoving())
+            event->accept();
+        d->lastPosTime = -1;
+        break;
+    case Qt::ScrollEnd:
+        d->pressed = false;
+        d->scrollingPhase = false;
+        d->draggingEnding();
+        returnToBounds();
+        d->lastPosTime = -1;
+        d->stealMouse = false;
+        if (!d->velocityTimeline.isActive() && !d->timeline.isActive())
+            movementEnding(true, true);
+        return;
+    }
+
+    qreal elapsed = qreal(currentTimestamp - d->lastPosTime) / qreal(1000);
+    if (elapsed <= 0) {
+        d->lastPosTime = currentTimestamp;
+        qCDebug(lcWheel) << "insufficient elapsed time: can't calculate velocity" << elapsed;
+        return;
+    }
+
+    if (event->source() == Qt::MouseEventNotSynthesized || event->pixelDelta().isNull() || event->phase() == Qt::NoScrollPhase) {
+        // no pixel delta (physical mouse wheel, or "dumb" touchpad), so use angleDelta
+        int xDelta = event->angleDelta().x();
+        int yDelta = event->angleDelta().y();
+
+        if (d->wheelDeceleration > _q_MaximumWheelDeceleration) {
+            const qreal wheelScroll = -qApp->styleHints()->wheelScrollLines() * 24;
+            // If wheelDeceleration is very large, i.e. the user or the platform does not want to have any mouse wheel
+            // acceleration behavior, we want to move a distance proportional to QStyleHints::wheelScrollLines()
+            if (yflick() && yDelta != 0) {
+                d->moveReason = StretchFlickablePrivate::Mouse; // ItemViews will set fixupMode to Immediate in fixup() without this.
+                d->vMoved = true;
+                qreal scrollPixel = (-yDelta / 120.0 * wheelScroll);
+                bool acceptEvent = true; // Set to false if event should propagate to parent
+                if (scrollPixel > 0) { // Forward direction (away from user)
+                    if (d->vData.move.value() >= minYExtent()) {
+                        d->vMoved = false;
+                        acceptEvent = false;
+                    }
+                } else { // Backward direction (towards user)
+                    if (d->vData.move.value() <= maxYExtent()) {
+                        d->vMoved = false;
+                        acceptEvent = false;
+                    }
+                }
+                if (d->vMoved) {
+                    if (d->boundsBehavior == StretchFlickable::StopAtBounds) {
+                        const qreal estContentPos = scrollPixel + d->vData.move.value();
+                        if (scrollPixel > 0) { // Forward direction (away from user)
+                            if (estContentPos > minYExtent()) {
+                                scrollPixel = minYExtent() - d->vData.move.value();
+                                acceptEvent = false;
+                            }
+                        } else { // Backward direction (towards user)
+                            if (estContentPos < maxYExtent()) {
+                                scrollPixel = maxYExtent() - d->vData.move.value();
+                                acceptEvent = false;
+                            }
+                        }
+                    }
+                    d->resetTimeline(d->vData);
+                    movementStarting();
+                    d->timeline.moveBy(d->vData.move, scrollPixel, QEasingCurve(QEasingCurve::OutExpo), 3*d->fixupDuration/4);
+                    d->vData.fixingUp = true;
+                    d->timeline.callback(StretchTimeLineCallback(&d->vData.move, StretchFlickablePrivate::fixupY_callback, d));
+                }
+                if (acceptEvent)
+                    event->accept();
+            }
+            if (xflick() && xDelta != 0) {
+                d->moveReason = StretchFlickablePrivate::Mouse; // ItemViews will set fixupMode to Immediate in fixup() without this.
+                d->hMoved = true;
+                qreal scrollPixel = (-xDelta / 120.0 * wheelScroll);
+                bool acceptEvent = true; // Set to false if event should propagate to parent
+                if (scrollPixel > 0) { // Forward direction (away from user)
+                    if (d->hData.move.value() >= minXExtent()) {
+                        d->hMoved = false;
+                        acceptEvent = false;
+                    }
+                } else { // Backward direction (towards user)
+                    if (d->hData.move.value() <= maxXExtent()) {
+                        d->hMoved = false;
+                        acceptEvent = false;
+                    }
+                }
+                if (d->hMoved) {
+                    if (d->boundsBehavior == StretchFlickable::StopAtBounds) {
+                        const qreal estContentPos = scrollPixel + d->hData.move.value();
+                        if (scrollPixel > 0) { // Forward direction (away from user)
+                            if (estContentPos > minXExtent()) {
+                                scrollPixel = minXExtent() - d->hData.move.value();
+                                acceptEvent = false;
+                            }
+                        } else { // Backward direction (towards user)
+                            if (estContentPos < maxXExtent()) {
+                                scrollPixel = maxXExtent() - d->hData.move.value();
+                                acceptEvent = false;
+                            }
+                        }
+                    }
+                    d->resetTimeline(d->hData);
+                    movementStarting();
+                    d->timeline.moveBy(d->hData.move, scrollPixel, QEasingCurve(QEasingCurve::OutExpo), 3*d->fixupDuration/4);
+                    d->hData.fixingUp = true;
+                    d->timeline.callback(StretchTimeLineCallback(&d->hData.move, StretchFlickablePrivate::fixupX_callback, d));
+                }
+                if (acceptEvent)
+                    event->accept();
+            }
+        } else {
+            // wheelDeceleration is set to some reasonable value: the user or the platform wants to have
+            // the classic Qt Quick mouse wheel acceleration behavior.
+            // For a single "clicky" wheel event (angleDelta +/- 120),
+            // we want flick() to end up moving a distance proportional to QStyleHints::wheelScrollLines().
+            // The decel algo from there is
+            // qreal dist = v2 / (accel * 2.0);
+            // i.e. initialWheelFlickDistance = (120 / dt)^2 / (deceleration * 2)
+            // now solve for dt:
+            // dt = 120 / sqrt(deceleration * 2 * initialWheelFlickDistance)
+            if (!isMoving())
+                elapsed = 120 / qSqrt(d->wheelDeceleration * 2 * d->initialWheelFlickDistance);
+            if (yflick() && yDelta != 0) {
+                qreal instVelocity = yDelta / elapsed;
+                // if the direction has changed, start over with filtering, to allow instant movement in the opposite direction
+                if ((instVelocity < 0 && d->vData.velocity > 0) || (instVelocity > 0 && d->vData.velocity < 0))
+                    d->vData.velocityBuffer.clear();
+                d->vData.addVelocitySample(instVelocity, d->maxVelocity);
+                d->vData.updateVelocity();
+                if ((yDelta > 0 && contentY() > -minYExtent()) || (yDelta < 0 && contentY() < -maxYExtent())) {
+                    const bool newFlick = d->flickY(event->type(), d->vData.velocity);
+                    if (newFlick && (d->vData.atBeginning != (yDelta > 0) || d->vData.atEnd != (yDelta < 0))) {
+                        d->flickingStarted(false, true);
+                        d->vMoved = true;
+                        movementStarting();
+                    }
+                    event->accept();
+                }
+            }
+            if (xflick() && xDelta != 0) {
+                qreal instVelocity = xDelta / elapsed;
+                // if the direction has changed, start over with filtering, to allow instant movement in the opposite direction
+                if ((instVelocity < 0 && d->hData.velocity > 0) || (instVelocity > 0 && d->hData.velocity < 0))
+                    d->hData.velocityBuffer.clear();
+                d->hData.addVelocitySample(instVelocity, d->maxVelocity);
+                d->hData.updateVelocity();
+                if ((xDelta > 0 && contentX() > -minXExtent()) || (xDelta < 0 && contentX() < -maxXExtent())) {
+                    const bool newFlick = d->flickX(event->type(), d->hData.velocity);
+                    if (newFlick && (d->hData.atBeginning != (xDelta > 0) || d->hData.atEnd != (xDelta < 0))) {
+                        d->flickingStarted(true, false);
+                        d->hMoved = true;
+                        movementStarting();
+                    }
+                    event->accept();
+                }
+            }
+        }
+    } else {
+        // use pixelDelta (probably from a trackpad): this is where we want to be on most platforms eventually
+        int xDelta = event->pixelDelta().x();
+        int yDelta = event->pixelDelta().y();
+
+        QVector2D velocity(xDelta / elapsed, yDelta / elapsed);
+        d->accumulatedWheelPixelDelta += QVector2D(event->pixelDelta());
+        // Try to drag if 1) we already are dragging or flicking, or
+        // 2) the flickable is free to flick both directions, or
+        // 3) the movement so far has been mostly horizontal AND it's free to flick horizontally, or
+        // 4) the movement so far has been mostly vertical AND it's free to flick vertically.
+        // Otherwise, wait until the next event.  Wheel events with pixel deltas tend to come frequently.
+        if (isMoving() || isFlicking() || (yflick() && xflick())
+                || (xflick() && qAbs(d->accumulatedWheelPixelDelta.x()) > qAbs(d->accumulatedWheelPixelDelta.y() * 2))
+                || (yflick() && qAbs(d->accumulatedWheelPixelDelta.y()) > qAbs(d->accumulatedWheelPixelDelta.x() * 2))) {
+            d->drag(currentTimestamp, event->type(), event->position(), d->accumulatedWheelPixelDelta,
+                    true, !d->scrollingPhase, true, velocity);
+            d->updateBeginningEnd();
+            if ((xflick() && !isAtXBeginning() && !isAtXEnd()) || (yflick() && !isAtYBeginning() && !isAtYEnd()))
+                event->accept();
+        } else {
+            qCDebug(lcWheel) << "not dragging: accumulated deltas" << d->accumulatedWheelPixelDelta <<
+                                "moving?" << isMoving() << "can flick horizontally?" << xflick() << "vertically?" << yflick();
+        }
+    }
+    d->lastPosTime = currentTimestamp;
+
+    if (!event->isAccepted())
+        QQuickItem::wheelEvent(event);
+}
+#endif
+
+bool StretchFlickablePrivate::isInnermostPressDelay(QQuickItem *i) const
+{
+    Q_Q(const StretchFlickable);
+    QQuickItem *item = i;
+    while (item) {
+        StretchFlickable *flick = qobject_cast<StretchFlickable*>(item);
+        if (flick && flick->pressDelay() > 0 && flick->isInteractive()) {
+            // Found the innermost flickable with press delay - is it me?
+            return (flick == q);
+        }
+        item = item->parentItem();
+    }
+    return false;
+}
+
+void StretchFlickablePrivate::captureDelayedPress(QQuickItem *item, QPointerEvent *event)
+{
+    Q_Q(StretchFlickable);
+    if (!q->window() || pressDelay <= 0)
+        return;
+
+    // Only the innermost flickable should handle the delayed press; this allows
+    // flickables up the parent chain to all see the events in their filter functions
+    if (!isInnermostPressDelay(item))
+        return;
+
+    delayedPressEvent = QQuickDeliveryAgentPrivate::clonePointerEvent(event);
+    delayedPressEvent->setAccepted(false);
+    delayedPressTimer.start(pressDelay, q);
+    qCDebug(lcReplay) << "begin press delay" << pressDelay << "ms with" << delayedPressEvent;
+}
+
+void StretchFlickablePrivate::clearDelayedPress()
+{
+    if (delayedPressEvent) {
+        delayedPressTimer.stop();
+        qCDebug(lcReplay) << "clear delayed press" << delayedPressEvent;
+        delete delayedPressEvent;
+        delayedPressEvent = nullptr;
+    }
+}
+
+void StretchFlickablePrivate::replayDelayedPress()
+{
+    Q_Q(StretchFlickable);
+    if (delayedPressEvent) {
+        // Losing the grab will clear the delayed press event; take control of it here
+        QScopedPointer<QPointerEvent> event(delayedPressEvent);
+        delayedPressEvent = nullptr;
+        delayedPressTimer.stop();
+
+        // If we have the grab, release before delivering the event
+        if (QQuickWindow *window = q->window()) {
+            auto da = deliveryAgentPrivate();
+            da->allowChildEventFiltering = false; // don't allow re-filtering during replay
+            replayingPressEvent = true;
+            auto &firstPoint = event->point(0);
+            // At first glance, it's weird for delayedPressEvent to already have a grabber;
+            // but on press, filterMouseEvent() took the exclusive grab, and that's stored
+            // in the device-specific EventPointData instance in QPointingDevicePrivate::activePoints,
+            // not in the event itself.  If this Flickable is still the grabber of that point on that device,
+            // that's the reason; but now it doesn't need that grab anymore.
+            if (event->exclusiveGrabber(firstPoint) == q)
+                event->setExclusiveGrabber(firstPoint, nullptr);
+
+            qCDebug(lcReplay) << "replaying" << event.data();
+            // Put scenePosition into position, for the sake of QQuickWindowPrivate::translateTouchEvent()
+            // TODO remove this if we remove QQuickWindowPrivate::translateTouchEvent()
+            QMutableEventPoint::setPosition(firstPoint, firstPoint.scenePosition());
+            // Send it through like a fresh press event, and let QQuickWindow
+            // (more specifically, QQuickWindowPrivate::deliverPressOrReleaseEvent)
+            // find the item or handler that should receive it, as usual.
+            QCoreApplication::sendEvent(window, event.data());
+            qCDebug(lcReplay) << "replay done";
+
+            // We're done with replay, go back to normal delivery behavior
+            replayingPressEvent = false;
+            da->allowChildEventFiltering = true;
+        }
+    }
+}
+
+//XXX pixelAligned ignores the global position of the Flickable, i.e. assumes Flickable itself is pixel aligned.
+
+/*!
+    \internal
+
+    This function is called from the timeline,
+    when advancement in the timeline is modifying the hData.move value.
+    The \a x argument is the newly updated value in hData.move.
+    The purpose of the function is to update the x position of the contentItem.
+*/
+void StretchFlickablePrivate::setViewportX(qreal x)
+{
+    Q_Q(StretchFlickable);
+    qreal effectiveX = pixelAligned ? -std::round(-x) : x;
+
+    const qreal maxX = q->maxXExtent();
+    const qreal minX = q->minXExtent();
+
+    if (boundsMovement == int(StretchFlickable::StopAtBounds))
+        effectiveX = qBound(maxX, effectiveX, minX);
+
+    contentItem->setX(effectiveX);
+    if (contentItem->x() != effectiveX)
+        return; // reentered
+
+    qreal overshoot = 0.0;
+    if (x <= maxX)
+        overshoot = maxX - x;
+    else if (x >= minX)
+        overshoot = minX - x;
+
+    if (overshoot != hData.overshoot) {
+        hData.overshoot = overshoot;
+        emit q->horizontalOvershootChanged();
+    }
+}
+
+/*!
+    \internal
+
+    This function is called from the timeline,
+    when advancement in the timeline is modifying the vData.move value.
+    The \a y argument is the newly updated value in vData.move.
+    The purpose of the function is to update the y position of the contentItem.
+*/
+void StretchFlickablePrivate::setViewportY(qreal y)
+{
+    Q_Q(StretchFlickable);
+    qreal effectiveY = pixelAligned ? -std::round(-y) : y;
+
+    const qreal maxY = q->maxYExtent();
+    const qreal minY = q->minYExtent();
+
+    if (boundsMovement == int(StretchFlickable::StopAtBounds))
+        effectiveY = qBound(maxY, effectiveY, minY);
+
+    contentItem->setY(effectiveY);
+    if (contentItem->y() != effectiveY)
+        return; // reentered
+
+    qreal overshoot = 0.0;
+    if (y <= maxY)
+        overshoot = maxY - y;
+    else if (y >= minY)
+        overshoot = minY - y;
+
+    if (overshoot != vData.overshoot) {
+        vData.overshoot = overshoot;
+        emit q->verticalOvershootChanged();
+    }
+}
+
+void StretchFlickable::timerEvent(QTimerEvent *event)
+{
+    Q_D(StretchFlickable);
+    if (event->timerId() == d->delayedPressTimer.timerId()) {
+        d->delayedPressTimer.stop();
+        if (d->delayedPressEvent) {
+            d->replayDelayedPress();
+        }
+    }
+}
+
+qreal StretchFlickable::minYExtent() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.startMargin;
+}
+
+qreal StretchFlickable::minXExtent() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.startMargin;
+}
+
+/* returns -ve */
+qreal StretchFlickable::maxXExtent() const
+{
+    Q_D(const StretchFlickable);
+    return qMin<qreal>(minXExtent(), width() - vWidth() - d->hData.endMargin);
+}
+/* returns -ve */
+qreal StretchFlickable::maxYExtent() const
+{
+    Q_D(const StretchFlickable);
+    return qMin<qreal>(minYExtent(), height() - vHeight() - d->vData.endMargin);
+}
+
+void StretchFlickable::componentComplete()
+{
+    Q_D(StretchFlickable);
+    QQuickItem::componentComplete();
+    if (!d->hData.explicitValue && d->hData.startMargin != 0.)
+        setContentX(-minXExtent());
+    if (!d->vData.explicitValue && d->vData.startMargin != 0.)
+        setContentY(-minYExtent());
+    if (lcWheel().isDebugEnabled() || lcVel().isDebugEnabled()) {
+        d->timeline.setObjectName(QLatin1String("timeline for Flickable ") + objectName());
+        d->velocityTimeline.setObjectName(QLatin1String("velocity timeline for Flickable ") + objectName());
+    }
+}
+
+void StretchFlickable::viewportMoved(Qt::Orientations orient)
+{
+    Q_D(StretchFlickable);
+    if (orient & Qt::Vertical)
+        d->viewportAxisMoved(d->vData, minYExtent(), maxYExtent(), d->fixupY_callback);
+    if (orient & Qt::Horizontal)
+        d->viewportAxisMoved(d->hData, minXExtent(), maxXExtent(), d->fixupX_callback);
+    d->updateBeginningEnd();
+}
+
+void StretchFlickablePrivate::viewportAxisMoved(AxisData &data, qreal minExtent, qreal maxExtent,
+                                           StretchTimeLineCallback::Callback fixupCallback)
+{
+    if (!scrollingPhase && (pressed || calcVelocity)) {
+        int elapsed = data.velocityTime.restart();
+        if (elapsed > 0) {
+            qreal velocity = (data.lastPos - data.move.value()) * 1000 / elapsed;
+            if (qAbs(velocity) > 0) {
+                velocityTimeline.reset(data.smoothVelocity);
+                velocityTimeline.set(data.smoothVelocity, velocity);
+                qCDebug(lcVel) << "touchpad scroll phase: velocity" << velocity;
+            }
+        }
+    } else {
+        if (timeline.time() > data.vTime) {
+            velocityTimeline.reset(data.smoothVelocity);
+            int dt = timeline.time() - data.vTime;
+            if (dt > 2) {
+                qreal velocity = (data.lastPos - data.move.value()) * 1000 / dt;
+                if (!qFuzzyCompare(data.smoothVelocity.value(), velocity))
+                    qCDebug(lcVel) << "velocity" << data.smoothVelocity.value() << "->" << velocity
+                                   << "computed as (" << data.lastPos << "-" << data.move.value() << ") * 1000 / ("
+                                   << timeline.time() << "-" << data.vTime << ")";
+                data.smoothVelocity.setValue(velocity);
+            }
+        }
+    }
+
+    if (!data.inOvershoot && !data.fixingUp && data.flicking
+            && (data.move.value() > minExtent || data.move.value() < maxExtent)
+            && qAbs(data.smoothVelocity.value()) > 10) {
+        // Increase deceleration if we've passed a bound
+        qreal overBound = data.move.value() > minExtent
+                ? data.move.value() - minExtent
+                : maxExtent - data.move.value();
+        data.inOvershoot = true;
+        qreal maxDistance = overShootDistance(qAbs(data.smoothVelocity.value())) - overBound;
+        resetTimeline(data);
+        if (maxDistance > 0)
+            timeline.accel(data.move, -data.smoothVelocity.value(), deceleration*QML_FLICK_OVERSHOOTFRICTION, maxDistance);
+        timeline.callback(StretchTimeLineCallback(&data.move, fixupCallback, this));
+    }
+
+    data.lastPos = data.move.value();
+    data.vTime = timeline.time();
+}
+
+void StretchFlickable::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
+{
+    Q_D(StretchFlickable);
+    QQuickItem::geometryChange(newGeometry, oldGeometry);
+
+    bool changed = false;
+    if (newGeometry.width() != oldGeometry.width()) {
+        changed = true; // we must update visualArea.widthRatio
+        if (d->hData.viewSize < 0)
+            d->contentItem->setWidth(width() - d->hData.startMargin - d->hData.endMargin);
+        // Make sure that we're entirely in view.
+        if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+            d->fixupMode = StretchFlickablePrivate::Immediate;
+            d->fixupX();
+        }
+    }
+    if (newGeometry.height() != oldGeometry.height()) {
+        changed = true; // we must update visualArea.heightRatio
+        if (d->vData.viewSize < 0)
+            d->contentItem->setHeight(height() - d->vData.startMargin - d->vData.endMargin);
+        // Make sure that we're entirely in view.
+        if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+            d->fixupMode = StretchFlickablePrivate::Immediate;
+            d->fixupY();
+        }
+    }
+
+    if (changed)
+        d->updateBeginningEnd();
+}
+
+/*!
+    \qmlmethod QtQuick::Flickable::flick(qreal xVelocity, qreal yVelocity)
+
+    Flicks the content with \a xVelocity horizontally and \a yVelocity vertically in pixels/sec.
+
+    Calling this method will update the corresponding moving and flicking properties and signals,
+    just like a real touchscreen flick.
+*/
+
+void StretchFlickable::flick(qreal xVelocity, qreal yVelocity)
+{
+    Q_D(StretchFlickable);
+    d->hData.reset();
+    d->vData.reset();
+    d->hData.velocity = xVelocity;
+    d->vData.velocity = yVelocity;
+    d->hData.vTime = d->vData.vTime = d->timeline.time();
+
+    const bool flickedX = xflick() && !qFuzzyIsNull(xVelocity) && d->flickX(QEvent::TouchUpdate, xVelocity);
+    const bool flickedY = yflick() && !qFuzzyIsNull(yVelocity) && d->flickY(QEvent::TouchUpdate, yVelocity);
+
+    if (flickedX)
+        d->hMoved = true;
+    if (flickedY)
+        d->vMoved = true;
+    movementStarting();
+    d->flickingStarted(flickedX, flickedY);
+}
+
+void StretchFlickablePrivate::flickingStarted(bool flickingH, bool flickingV)
+{
+    Q_Q(StretchFlickable);
+    if (!flickingH && !flickingV)
+        return;
+
+    bool wasFlicking = hData.flicking || vData.flicking;
+    if (flickingH && !hData.flicking) {
+        hData.flicking = true;
+        emit q->flickingHorizontallyChanged();
+    }
+    if (flickingV && !vData.flicking) {
+        vData.flicking = true;
+        emit q->flickingVerticallyChanged();
+    }
+    if (!wasFlicking && (hData.flicking || vData.flicking)) {
+        emit q->flickingChanged();
+        emit q->flickStarted();
+    }
+}
+
+/*!
+    \qmlmethod QtQuick::Flickable::cancelFlick()
+
+    Cancels the current flick animation.
+*/
+
+void StretchFlickable::cancelFlick()
+{
+    Q_D(StretchFlickable);
+    d->resetTimeline(d->hData);
+    d->resetTimeline(d->vData);
+    movementEnding();
+}
+
+void StretchFlickablePrivate::data_append(QQmlListProperty<QObject> *prop, QObject *o)
+{
+    if (!prop || !prop->data)
+        return;
+
+    if (QQuickItem *i = qmlobject_cast<QQuickItem *>(o)) {
+        i->setParentItem(static_cast<StretchFlickablePrivate*>(prop->data)->contentItem);
+    } else if (QQuickPointerHandler *pointerHandler = qmlobject_cast<QQuickPointerHandler *>(o)) {
+        static_cast<StretchFlickablePrivate*>(prop->data)->addPointerHandler(pointerHandler);
+    } else {
+        o->setParent(prop->object); // XXX todo - do we want this?
+    }
+}
+
+qsizetype StretchFlickablePrivate::data_count(QQmlListProperty<QObject> *)
+{
+    // XXX todo
+    return 0;
+}
+
+QObject *StretchFlickablePrivate::data_at(QQmlListProperty<QObject> *, qsizetype)
+{
+    // XXX todo
+    return nullptr;
+}
+
+void StretchFlickablePrivate::data_clear(QQmlListProperty<QObject> *)
+{
+    // XXX todo
+}
+
+QQmlListProperty<QObject> StretchFlickable::flickableData()
+{
+    Q_D(StretchFlickable);
+    return QQmlListProperty<QObject>(this, (void *)d, StretchFlickablePrivate::data_append,
+                                             StretchFlickablePrivate::data_count,
+                                             StretchFlickablePrivate::data_at,
+                                             StretchFlickablePrivate::data_clear);
+}
+
+QQmlListProperty<QQuickItem> StretchFlickable::flickableChildren()
+{
+    Q_D(StretchFlickable);
+    return QQuickItemPrivate::get(d->contentItem)->children();
+}
+
+/*!
+    \qmlproperty enumeration QtQuick::Flickable::boundsBehavior
+    This property holds whether the surface may be dragged
+    beyond the Flickable's boundaries, or overshoot the
+    Flickable's boundaries when flicked.
+
+    When the \l boundsMovement is \c Flickable.FollowBoundsBehavior, a value
+    other than \c Flickable.StopAtBounds will give a feeling that the edges of
+    the view are soft, rather than a hard physical boundary.
+
+    The \c boundsBehavior can be one of:
+
+    \list
+    \li Flickable.StopAtBounds - the contents can not be dragged beyond the boundary
+    of the flickable, and flicks will not overshoot.
+    \li Flickable.DragOverBounds - the contents can be dragged beyond the boundary
+    of the Flickable, but flicks will not overshoot.
+    \li Flickable.OvershootBounds - the contents can overshoot the boundary when flicked,
+    but the content cannot be dragged beyond the boundary of the flickable. (since \c{QtQuick 2.5})
+    \li Flickable.DragAndOvershootBounds (default) - the contents can be dragged
+    beyond the boundary of the Flickable, and can overshoot the
+    boundary when flicked.
+    \endlist
+
+    \sa horizontalOvershoot, verticalOvershoot, boundsMovement
+*/
+StretchFlickable::BoundsBehavior StretchFlickable::boundsBehavior() const
+{
+    Q_D(const StretchFlickable);
+    return d->boundsBehavior;
+}
+
+void StretchFlickable::setBoundsBehavior(BoundsBehavior b)
+{
+    Q_D(StretchFlickable);
+    if (b == d->boundsBehavior)
+        return;
+    d->boundsBehavior = b;
+    emit boundsBehaviorChanged();
+}
+
+/*!
+    \qmlproperty Transition QtQuick::Flickable::rebound
+
+    This holds the transition to be applied to the content view when
+    it snaps back to the bounds of the flickable. The transition is
+    triggered when the view is flicked or dragged past the edge of the
+    content area, or when returnToBounds() is called.
+
+    \qml
+    import QtQuick 2.0
+
+    Flickable {
+        width: 150; height: 150
+        contentWidth: 300; contentHeight: 300
+
+        rebound: Transition {
+            NumberAnimation {
+                properties: "x,y"
+                duration: 1000
+                easing.type: Easing.OutBounce
+            }
+        }
+
+        Rectangle {
+            width: 300; height: 300
+            gradient: Gradient {
+                GradientStop { position: 0.0; color: "lightsteelblue" }
+                GradientStop { position: 1.0; color: "blue" }
+            }
+        }
+    }
+    \endqml
+
+    When the above view is flicked beyond its bounds, it will return to its
+    bounds using the transition specified:
+
+    \image flickable-rebound.gif
+
+    If this property is not set, a default animation is applied.
+  */
+QQuickTransition *StretchFlickable::rebound() const
+{
+    Q_D(const StretchFlickable);
+    return d->rebound;
+}
+
+void StretchFlickable::setRebound(QQuickTransition *transition)
+{
+    Q_D(StretchFlickable);
+    if (transition) {
+        if (!d->hData.transitionToBounds)
+            d->hData.transitionToBounds = new StretchFlickableReboundTransition(this, QLatin1String("x"));
+        if (!d->vData.transitionToBounds)
+            d->vData.transitionToBounds = new StretchFlickableReboundTransition(this, QLatin1String("y"));
+    }
+    if (d->rebound != transition) {
+        d->rebound = transition;
+        emit reboundChanged();
+    }
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::contentWidth
+    \qmlproperty real QtQuick::Flickable::contentHeight
+
+    The dimensions of the content (the surface controlled by Flickable).
+    This should typically be set to the combined size of the items placed in the
+    Flickable.
+
+    The following snippet shows how these properties are used to display
+    an image that is larger than the Flickable item itself:
+
+    \snippet qml/flickable.qml document
+
+    In some cases, the content dimensions can be automatically set
+    based on the \l {Item::childrenRect.width}{childrenRect.width}
+    and \l {Item::childrenRect.height}{childrenRect.height} properties
+    of the \l contentItem. For example, the previous snippet could be rewritten with:
+
+    \code
+    contentWidth: contentItem.childrenRect.width; contentHeight: contentItem.childrenRect.height
+    \endcode
+
+    Though this assumes that the origin of the childrenRect is 0,0.
+*/
+qreal StretchFlickable::contentWidth() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.viewSize;
+}
+
+void StretchFlickable::setContentWidth(qreal w)
+{
+    Q_D(StretchFlickable);
+    if (d->hData.viewSize == w)
+        return;
+    d->hData.viewSize = w;
+    if (w < 0)
+        d->contentItem->setWidth(width() - d->hData.startMargin - d->hData.endMargin);
+    else
+        d->contentItem->setWidth(w);
+    d->hData.markExtentsDirty();
+    // Make sure that we're entirely in view.
+    if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+        d->fixupMode = StretchFlickablePrivate::Immediate;
+        d->fixupX();
+    } else if (!d->pressed && d->hData.fixingUp) {
+        d->fixupMode = StretchFlickablePrivate::ExtentChanged;
+        d->fixupX();
+    }
+    emit contentWidthChanged();
+    d->updateBeginningEnd();
+}
+
+qreal StretchFlickable::contentHeight() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.viewSize;
+}
+
+void StretchFlickable::setContentHeight(qreal h)
+{
+    Q_D(StretchFlickable);
+    if (d->vData.viewSize == h)
+        return;
+    d->vData.viewSize = h;
+    if (h < 0)
+        d->contentItem->setHeight(height() - d->vData.startMargin - d->vData.endMargin);
+    else
+        d->contentItem->setHeight(h);
+    d->vData.markExtentsDirty();
+    // Make sure that we're entirely in view.
+    if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+        d->fixupMode = StretchFlickablePrivate::Immediate;
+        d->fixupY();
+    } else if (!d->pressed && d->vData.fixingUp) {
+        d->fixupMode = StretchFlickablePrivate::ExtentChanged;
+        d->fixupY();
+    }
+    emit contentHeightChanged();
+    d->updateBeginningEnd();
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::topMargin
+    \qmlproperty real QtQuick::Flickable::leftMargin
+    \qmlproperty real QtQuick::Flickable::bottomMargin
+    \qmlproperty real QtQuick::Flickable::rightMargin
+
+    These properties hold the margins around the content.  This space is reserved
+    in addition to the contentWidth and contentHeight.
+*/
+
+
+qreal StretchFlickable::topMargin() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.startMargin;
+}
+
+void StretchFlickable::setTopMargin(qreal m)
+{
+    Q_D(StretchFlickable);
+    if (d->vData.startMargin == m)
+        return;
+    d->vData.startMargin = m;
+    d->vData.markExtentsDirty();
+    if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+        d->fixupMode = StretchFlickablePrivate::Immediate;
+        d->fixupY();
+    }
+    emit topMarginChanged();
+    d->updateBeginningEnd();
+}
+
+qreal StretchFlickable::bottomMargin() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.endMargin;
+}
+
+void StretchFlickable::setBottomMargin(qreal m)
+{
+    Q_D(StretchFlickable);
+    if (d->vData.endMargin == m)
+        return;
+    d->vData.endMargin = m;
+    d->vData.markExtentsDirty();
+    if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+        d->fixupMode = StretchFlickablePrivate::Immediate;
+        d->fixupY();
+    }
+    emit bottomMarginChanged();
+    d->updateBeginningEnd();
+}
+
+qreal StretchFlickable::leftMargin() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.startMargin;
+}
+
+void StretchFlickable::setLeftMargin(qreal m)
+{
+    Q_D(StretchFlickable);
+    if (d->hData.startMargin == m)
+        return;
+    d->hData.startMargin = m;
+    d->hData.markExtentsDirty();
+    if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+        d->fixupMode = StretchFlickablePrivate::Immediate;
+        d->fixupX();
+    }
+    emit leftMarginChanged();
+    d->updateBeginningEnd();
+}
+
+qreal StretchFlickable::rightMargin() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.endMargin;
+}
+
+void StretchFlickable::setRightMargin(qreal m)
+{
+    Q_D(StretchFlickable);
+    if (d->hData.endMargin == m)
+        return;
+    d->hData.endMargin = m;
+    d->hData.markExtentsDirty();
+    if (!d->pressed && !d->hData.moving && !d->vData.moving) {
+        d->fixupMode = StretchFlickablePrivate::Immediate;
+        d->fixupX();
+    }
+    emit rightMarginChanged();
+    d->updateBeginningEnd();
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::originX
+    \qmlproperty real QtQuick::Flickable::originY
+
+    These properties hold the origin of the content. This value always refers
+    to the top-left position of the content regardless of layout direction.
+
+    This is usually (0,0), however ListView and GridView may have an arbitrary
+    origin due to delegate size variation, or item insertion/removal outside
+    the visible region.
+
+    \sa contentX, contentY
+*/
+
+qreal StretchFlickable::originY() const
+{
+    Q_D(const StretchFlickable);
+    return -minYExtent() + d->vData.startMargin;
+}
+
+qreal StretchFlickable::originX() const
+{
+    Q_D(const StretchFlickable);
+    return -minXExtent() + d->hData.startMargin;
+}
+
+
+/*!
+    \qmlmethod QtQuick::Flickable::resizeContent(real width, real height, QPointF center)
+
+    Resizes the content to \a width x \a height about \a center.
+
+    This does not scale the contents of the Flickable - it only resizes the \l contentWidth
+    and \l contentHeight.
+
+    Resizing the content may result in the content being positioned outside
+    the bounds of the Flickable.  Calling \l returnToBounds() will
+    move the content back within legal bounds.
+*/
+void StretchFlickable::resizeContent(qreal w, qreal h, QPointF center)
+{
+    Q_D(StretchFlickable);
+    const qreal oldHSize = d->hData.viewSize;
+    const qreal oldVSize = d->vData.viewSize;
+    const bool needToUpdateWidth = w != oldHSize;
+    const bool needToUpdateHeight = h != oldVSize;
+    d->hData.viewSize = w;
+    d->vData.viewSize = h;
+    d->contentItem->setSize(QSizeF(w, h));
+    if (needToUpdateWidth)
+        emit contentWidthChanged();
+    if (needToUpdateHeight)
+        emit contentHeightChanged();
+
+    if (center.x() != 0) {
+        qreal pos = center.x() * w / oldHSize;
+        setContentX(contentX() + pos - center.x());
+    }
+    if (center.y() != 0) {
+        qreal pos = center.y() * h / oldVSize;
+        setContentY(contentY() + pos - center.y());
+    }
+    d->updateBeginningEnd();
+}
+
+/*!
+    \qmlmethod QtQuick::Flickable::returnToBounds()
+
+    Ensures the content is within legal bounds.
+
+    This may be called to ensure that the content is within legal bounds
+    after manually positioning the content.
+*/
+void StretchFlickable::returnToBounds()
+{
+    Q_D(StretchFlickable);
+    d->fixupX();
+    d->fixupY();
+}
+
+qreal StretchFlickable::vWidth() const
+{
+    Q_D(const StretchFlickable);
+    if (d->hData.viewSize < 0)
+        return width();
+    else
+        return d->hData.viewSize;
+}
+
+qreal StretchFlickable::vHeight() const
+{
+    Q_D(const StretchFlickable);
+    if (d->vData.viewSize < 0)
+        return height();
+    else
+        return d->vData.viewSize;
+}
+
+/*!
+    \internal
+
+    The setFlickableDirection function can be used to set constraints on which axis the contentItem can be flicked along.
+
+    \return true if the flickable is allowed to flick in the horizontal direction, otherwise returns false
+*/
+bool StretchFlickable::xflick() const
+{
+    Q_D(const StretchFlickable);
+    const int contentWidthWithMargins = d->contentItem->width() + d->hData.startMargin + d->hData.endMargin;
+    if ((d->flickableDirection & StretchFlickable::AutoFlickIfNeeded) && (contentWidthWithMargins > width()))
+        return true;
+    if (d->flickableDirection == StretchFlickable::AutoFlickDirection)
+        return std::floor(qAbs(contentWidthWithMargins - width()));
+    return d->flickableDirection & StretchFlickable::HorizontalFlick;
+}
+
+/*!
+    \internal
+
+    The setFlickableDirection function can be used to set constraints on which axis the contentItem can be flicked along.
+
+    \return true if the flickable is allowed to flick in the vertical direction, otherwise returns false.
+*/
+bool StretchFlickable::yflick() const
+{
+    Q_D(const StretchFlickable);
+    const int contentHeightWithMargins = d->contentItem->height() + d->vData.startMargin + d->vData.endMargin;
+    if ((d->flickableDirection & StretchFlickable::AutoFlickIfNeeded) && (contentHeightWithMargins > height()))
+        return true;
+    if (d->flickableDirection == StretchFlickable::AutoFlickDirection)
+        return std::floor(qAbs(contentHeightWithMargins - height()));
+    return d->flickableDirection & StretchFlickable::VerticalFlick;
+}
+
+void StretchFlickable::mouseUngrabEvent()
+{
+    Q_D(StretchFlickable);
+    // if our mouse grab has been removed (probably by another Flickable),
+    // fix our state
+    if (!d->replayingPressEvent)
+        d->cancelInteraction();
+}
+
+void StretchFlickablePrivate::cancelInteraction()
+{
+    Q_Q(StretchFlickable);
+    if (pressed) {
+        clearDelayedPress();
+        pressed = false;
+        draggingEnding();
+        stealMouse = false;
+        q->setKeepMouseGrab(false);
+        fixupX();
+        fixupY();
+        if (!isViewMoving())
+            q->movementEnding();
+    }
+}
+
+void StretchFlickablePrivate::addPointerHandler(QQuickPointerHandler *h)
+{
+    Q_Q(const StretchFlickable);
+    qCDebug(lcStretchHandlerParent) << "reparenting handler" << h << "to contentItem of" << q;
+    h->setParent(contentItem);
+    QQuickItemPrivate::get(contentItem)->addPointerHandler(h);
+}
+
+/*! \internal
+    StretchFlickable::filterPointerEvent filters pointer events intercepted on the way
+    to the child \a receiver, and potentially steals the exclusive grab.
+
+    This is how flickable takes over the handling of events from child items.
+
+    Returns true if the event will be stolen and should <em>not</em> be delivered to the \a receiver.
+*/
+bool StretchFlickable::filterPointerEvent(QQuickItem *receiver, QPointerEvent *event)
+{
+    Q_D(StretchFlickable);
+    const bool isTouch = QQuickDeliveryAgentPrivate::isTouchEvent(event);
+    const bool isMouse = QQuickDeliveryAgentPrivate::isMouseEvent(event);
+    if (isMouse || QQuickDeliveryAgentPrivate::isTabletEvent(event)) {
+        if (!d->buttonsAccepted(static_cast<QSinglePointEvent *>(event)))
+            return QQuickItem::childMouseEventFilter(receiver, event);
+    } else if (!isTouch) {
+        return false; // don't filter hover events or wheel events, for example
+    }
+    Q_ASSERT_X(receiver != this, "", "Flickable received a filter event for itself");
+    // If a touch event contains a new press point, don't steal right away: watch the movements for a while
+    if (isTouch && static_cast<QTouchEvent *>(event)->touchPointStates().testFlag(QEventPoint::State::Pressed))
+        d->stealMouse = false;
+    // If multiple touchpoints are within bounds, don't grab: it's probably meant for multi-touch interaction in some child
+    if (event->pointCount() > 1) {
+        qCDebug(lcFilter) << objectName() << "ignoring multi-touch" << event << "for" << receiver;
+        d->stealMouse = false;
+        return false;
+    } else {
+        qCDebug(lcFilter) << objectName() << "filtering" << event << "for" << receiver;
+    }
+
+    const auto &firstPoint = event->points().first();
+
+    if (event->pointCount() == 1 && event->exclusiveGrabber(firstPoint) == this) {
+        // We have an exclusive grab (since we're e.g dragging), but at the same time, we have
+        // a child with a passive grab (which is why this filter is being called). And because
+        // of that, we end up getting the same pointer events twice; First in our own event
+        // handlers (because of the grab), then once more in here, since we filter the child.
+        // To avoid processing the event twice (e.g avoid calling handleReleaseEvent once more
+        // from below), we mark the event as filtered, and simply return.
+        event->setAccepted(true);
+        return true;
+    }
+
+    QPointF localPos = mapFromScene(firstPoint.scenePosition());
+    bool receiverDisabled = receiver && !receiver->isEnabled();
+    bool stealThisEvent = d->stealMouse;
+    bool receiverKeepsGrab = receiver && (receiver->keepMouseGrab() || receiver->keepTouchGrab());
+    bool receiverRelinquishGrab = false;
+
+    // Special case for MouseArea, try to guess what it does with the event
+    if (auto *mouseArea = qmlobject_cast<QQuickMouseArea *>(receiver)) {
+        bool preventStealing = mouseArea->preventStealing();
+#if QT_CONFIG(quick_draganddrop)
+        if (mouseArea->drag() && mouseArea->drag()->target())
+            preventStealing = true;
+#endif
+        if (!preventStealing && receiverKeepsGrab) {
+            receiverRelinquishGrab = !receiverDisabled || (isMouse
+                        && firstPoint.state() == QEventPoint::State::Pressed
+                        && (receiver->acceptedMouseButtons() & static_cast<QMouseEvent *>(event)->button()));
+            if (receiverRelinquishGrab)
+                receiverKeepsGrab = false;
+        }
+    }
+
+    if ((stealThisEvent || contains(localPos)) && (!receiver || !receiverKeepsGrab || receiverDisabled)) {
+        QScopedPointer<QPointerEvent> localizedEvent(QQuickDeliveryAgentPrivate::clonePointerEvent(event, localPos));
+        localizedEvent->setAccepted(false);
+        switch (firstPoint.state()) {
+        case QEventPoint::State::Updated:
+            d->handleMoveEvent(localizedEvent.data());
+            break;
+        case QEventPoint::State::Pressed:
+            d->handlePressEvent(localizedEvent.data());
+            d->captureDelayedPress(receiver, event);
+            // never grab the pointing device on press during filtering: do it later, during a move
+            d->stealMouse = false;
+            stealThisEvent = false;
+            break;
+        case QEventPoint::State::Released:
+            d->handleReleaseEvent(localizedEvent.data());
+            stealThisEvent = d->stealMouse;
+            break;
+        case QEventPoint::State::Stationary:
+        case QEventPoint::State::Unknown:
+            break;
+        }
+        if ((receiver && stealThisEvent && !receiverKeepsGrab && receiver != this) || receiverDisabled) {
+            d->clearDelayedPress();
+            event->setExclusiveGrabber(firstPoint, this);
+        } else if (d->delayedPressEvent) {
+            event->setExclusiveGrabber(firstPoint, this);
+        }
+        /*
+            Note that d->stealMouse can be false before the call to d->handleMoveEvent(), but true
+            afterwards. That means we detected a drag. But even so, we deliberately don't filter
+            the move event that cause this to happen, since the user might actually be dragging on
+            a child item, such as a Slider, in which case the child should get a chance to detect
+            the drag instead, and take the grab. Only if we receive another move event after this,
+            without the child grabbing the mouse in-between, do we initiate a flick.
+            An exception is if the user is already in a flicking session started from an earlier
+            drag, meaning that the content item is still moving (isMoving() == true). In that
+            case, we see any subsequent drags as being a continuation of the flicking.
+            Then we filter all events straight away, to avoid triggering any taps or drags in a child.
+        */
+        if (isMoving() || (!receiverRelinquishGrab && (stealThisEvent || d->delayedPressEvent || receiverDisabled))) {
+            // Filter the event
+            event->setAccepted(true);
+            return true;
+        }
+
+        // Don't filter the event
+        return false;
+    } else if (d->lastPosTime != -1) {
+        d->lastPosTime = -1;
+        returnToBounds();
+    }
+    if (firstPoint.state() == QEventPoint::State::Released || (receiverKeepsGrab && !receiverDisabled)) {
+        // mouse released, or another item has claimed the grab
+        d->lastPosTime = -1;
+        d->clearDelayedPress();
+        d->stealMouse = false;
+        d->pressed = false;
+    }
+    return false;
+}
+
+/*! \internal
+    Despite the name, this function filters all pointer events on their way to any child within.
+    Returns true if the event will be stolen and should <em>not</em> be delivered to the \a receiver.
+*/
+bool StretchFlickable::childMouseEventFilter(QQuickItem *i, QEvent *e)
+{
+    Q_D(StretchFlickable);
+    QPointerEvent *pointerEvent = e->isPointerEvent() ? static_cast<QPointerEvent *>(e) : nullptr;
+
+    auto wantsPointerEvent_helper = [this, d, i, pointerEvent]() {
+        Q_ASSERT(pointerEvent);
+        QQuickDeliveryAgentPrivate::localizePointerEvent(pointerEvent, this);
+        const bool wants = d->wantsPointerEvent(pointerEvent);
+        // re-localize event back to \a i before returning
+        QQuickDeliveryAgentPrivate::localizePointerEvent(pointerEvent, i);
+        return wants;
+    };
+
+    if (!isVisible() || !isEnabled() || !isInteractive() ||
+            (pointerEvent && !wantsPointerEvent_helper())) {
+        d->cancelInteraction();
+        return QQuickItem::childMouseEventFilter(i, e);
+    }
+
+    if (e->type() == QEvent::UngrabMouse) {
+        Q_ASSERT(e->isSinglePointEvent());
+        auto spe = static_cast<QSinglePointEvent *>(e);
+        const QObject *grabber = spe->exclusiveGrabber(spe->points().first());
+        qCDebug(lcFilter) << "filtering UngrabMouse" << spe->points().first() << "for" << i << "grabber is" << grabber;
+        if (grabber != this)
+            mouseUngrabEvent(); // A child has been ungrabbed
+    } else if (pointerEvent) {
+        return filterPointerEvent(i, pointerEvent);
+    }
+
+    return QQuickItem::childMouseEventFilter(i, e);
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::maximumFlickVelocity
+    This property holds the maximum velocity that the user can flick the view in pixels/second.
+
+    The default value is platform dependent.
+*/
+qreal StretchFlickable::maximumFlickVelocity() const
+{
+    Q_D(const StretchFlickable);
+    return d->maxVelocity;
+}
+
+void StretchFlickable::setMaximumFlickVelocity(qreal v)
+{
+    Q_D(StretchFlickable);
+    if (v == d->maxVelocity)
+        return;
+    d->maxVelocity = v;
+    emit maximumFlickVelocityChanged();
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::flickDeceleration
+    This property holds the rate at which a flick will decelerate:
+    the higher the number, the faster it slows down when the user stops
+    flicking via touch. For example 0.0001 is nearly
+    "frictionless", and 10000 feels quite "sticky".
+
+    The default value is platform dependent. Values of zero or less are not allowed.
+*/
+qreal StretchFlickable::flickDeceleration() const
+{
+    Q_D(const StretchFlickable);
+    return d->deceleration;
+}
+
+void StretchFlickable::setFlickDeceleration(qreal deceleration)
+{
+    Q_D(StretchFlickable);
+    if (deceleration == d->deceleration)
+        return;
+    d->deceleration = qMax(0.001, deceleration);
+    emit flickDecelerationChanged();
+}
+
+qreal StretchFlickable::dragResistanceRange() const
+{
+    Q_D(const StretchFlickable);
+    return d->dragResistanceRange;
+}
+
+void StretchFlickable::setDragResistanceRange(qreal range)
+{
+    Q_D(StretchFlickable);
+    range = qMax(qreal(1), range);
+    if (range == d->dragResistanceRange)
+        return;
+    d->dragResistanceRange = range;
+    emit dragResistanceRangeChanged();
+}
+
+qreal StretchFlickable::dragOvershootMax() const
+{
+    Q_D(const StretchFlickable);
+    return d->dragOvershootMax;
+}
+
+void StretchFlickable::setDragOvershootMax(qreal maxOvershoot)
+{
+    Q_D(StretchFlickable);
+    maxOvershoot = qMax(qreal(0), maxOvershoot);
+    if (maxOvershoot == d->dragOvershootMax)
+        return;
+    d->dragOvershootMax = maxOvershoot;
+    emit dragOvershootMaxChanged();
+}
+
+bool StretchFlickable::isFlicking() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.flicking ||  d->vData.flicking;
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::flicking
+    \qmlproperty bool QtQuick::Flickable::flickingHorizontally
+    \qmlproperty bool QtQuick::Flickable::flickingVertically
+
+    These properties describe whether the view is currently moving horizontally,
+    vertically or in either direction, due to the user flicking the view.
+*/
+bool StretchFlickable::isFlickingHorizontally() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.flicking;
+}
+
+bool StretchFlickable::isFlickingVertically() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.flicking;
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::dragging
+    \qmlproperty bool QtQuick::Flickable::draggingHorizontally
+    \qmlproperty bool QtQuick::Flickable::draggingVertically
+
+    These properties describe whether the view is currently moving horizontally,
+    vertically or in either direction, due to the user dragging the view.
+*/
+bool StretchFlickable::isDragging() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.dragging ||  d->vData.dragging;
+}
+
+bool StretchFlickable::isDraggingHorizontally() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.dragging;
+}
+
+bool StretchFlickable::isDraggingVertically() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.dragging;
+}
+
+void StretchFlickablePrivate::draggingStarting()
+{
+    Q_Q(StretchFlickable);
+    bool wasDragging = hData.dragging || vData.dragging;
+    if (hMoved && !hData.dragging) {
+        hData.dragging = true;
+        emit q->draggingHorizontallyChanged();
+    }
+    if (vMoved && !vData.dragging) {
+        vData.dragging = true;
+        emit q->draggingVerticallyChanged();
+    }
+    if (!wasDragging && (hData.dragging || vData.dragging)) {
+        emit q->draggingChanged();
+        emit q->dragStarted();
+    }
+}
+
+void StretchFlickablePrivate::draggingEnding()
+{
+    Q_Q(StretchFlickable);
+    const bool wasDragging = hData.dragging || vData.dragging;
+    if (hData.dragging) {
+        hData.dragging = false;
+        emit q->draggingHorizontallyChanged();
+    }
+    if (vData.dragging) {
+        vData.dragging = false;
+        emit q->draggingVerticallyChanged();
+    }
+    if (wasDragging) {
+        if (!hData.dragging && !vData.dragging) {
+            emit q->draggingChanged();
+            emit q->dragEnded();
+        }
+        hData.inRebound = false;
+        vData.inRebound = false;
+    }
+}
+
+bool StretchFlickablePrivate::isViewMoving() const
+{
+    if (timeline.isActive()
+            || (hData.transitionToBounds && hData.transitionToBounds->isActive())
+            || (vData.transitionToBounds && vData.transitionToBounds->isActive()) ) {
+        return true;
+    }
+    return false;
+}
+
+/*!
+    \qmlproperty int QtQuick::Flickable::pressDelay
+
+    This property holds the time to delay (ms) delivering a press to
+    children of the Flickable.  This can be useful where reacting
+    to a press before a flicking action has undesirable effects.
+
+    If the flickable is dragged/flicked before the delay times out
+    the press event will not be delivered.  If the button is released
+    within the timeout, both the press and release will be delivered.
+
+    Note that for nested Flickables with pressDelay set, the pressDelay of
+    outer Flickables is overridden by the innermost Flickable. If the drag
+    exceeds the platform drag threshold, the press event will be delivered
+    regardless of this property.
+
+    \sa QStyleHints
+*/
+int StretchFlickable::pressDelay() const
+{
+    Q_D(const StretchFlickable);
+    return d->pressDelay;
+}
+
+void StretchFlickable::setPressDelay(int delay)
+{
+    Q_D(StretchFlickable);
+    if (d->pressDelay == delay)
+        return;
+    d->pressDelay = delay;
+    emit pressDelayChanged();
+}
+
+/*!
+    \qmlproperty bool QtQuick::Flickable::moving
+    \qmlproperty bool QtQuick::Flickable::movingHorizontally
+    \qmlproperty bool QtQuick::Flickable::movingVertically
+
+    These properties describe whether the view is currently moving horizontally,
+    vertically or in either direction, due to the user either dragging or
+    flicking the view.
+*/
+
+bool StretchFlickable::isMoving() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.moving || d->vData.moving;
+}
+
+bool StretchFlickable::isMovingHorizontally() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.moving;
+}
+
+bool StretchFlickable::isMovingVertically() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.moving;
+}
+
+void StretchFlickable::velocityTimelineCompleted()
+{
+    Q_D(StretchFlickable);
+    if ( (d->hData.transitionToBounds && d->hData.transitionToBounds->isActive())
+         || (d->vData.transitionToBounds && d->vData.transitionToBounds->isActive()) ) {
+        return;
+    }
+    // With subclasses such as GridView, velocityTimeline.completed is emitted repeatedly:
+    // for example setting currentIndex results in a visual "flick" which the user
+    // didn't initiate directly. We don't want to end movement repeatedly, and in
+    // that case movementEnding will happen after the sequence of movements ends.
+    if (d->vData.flicking)
+        movementEnding();
+    d->updateBeginningEnd();
+}
+
+void StretchFlickable::timelineCompleted()
+{
+    Q_D(StretchFlickable);
+    if ( (d->hData.transitionToBounds && d->hData.transitionToBounds->isActive())
+         || (d->vData.transitionToBounds && d->vData.transitionToBounds->isActive()) ) {
+        return;
+    }
+    movementEnding();
+    d->updateBeginningEnd();
+}
+
+void StretchFlickable::movementStarting()
+{
+    Q_D(StretchFlickable);
+    bool wasMoving = d->hData.moving || d->vData.moving;
+    if (d->hMoved && !d->hData.moving) {
+        d->hData.moving = true;
+        emit movingHorizontallyChanged();
+    }
+    if (d->vMoved && !d->vData.moving) {
+        d->vData.moving = true;
+        emit movingVerticallyChanged();
+    }
+
+    if (!wasMoving && (d->hData.moving || d->vData.moving)) {
+        emit movingChanged();
+        emit movementStarted();
+#if QT_CONFIG(accessibility)
+        if (QAccessible::isActive()) {
+            QAccessibleEvent ev(this, QAccessible::ScrollingStart);
+            QAccessible::updateAccessibility(&ev);
+        }
+#endif
+    }
+}
+
+void StretchFlickable::movementEnding()
+{
+    movementEnding(true, true);
+}
+
+void StretchFlickable::movementEnding(bool hMovementEnding, bool vMovementEnding)
+{
+    Q_D(StretchFlickable);
+
+    // emit flicking signals
+    const bool wasFlicking = d->hData.flicking || d->vData.flicking;
+    if (hMovementEnding && d->hData.flicking) {
+        d->hData.flicking = false;
+        emit flickingHorizontallyChanged();
+    }
+    if (vMovementEnding && d->vData.flicking) {
+        d->vData.flicking = false;
+        emit flickingVerticallyChanged();
+    }
+    if (wasFlicking && (!d->hData.flicking || !d->vData.flicking)) {
+        emit flickingChanged();
+        emit flickEnded();
+    } else if (d->hData.flickingWhenDragBegan || d->vData.flickingWhenDragBegan) {
+        d->hData.flickingWhenDragBegan = !hMovementEnding;
+        d->vData.flickingWhenDragBegan = !vMovementEnding;
+        emit flickEnded();
+    }
+
+    // emit moving signals
+    bool wasMoving = isMoving();
+    if (hMovementEnding && d->hData.moving
+            && (!d->pressed && !d->stealMouse)) {
+        d->hData.moving = false;
+        d->hMoved = false;
+        emit movingHorizontallyChanged();
+    }
+    if (vMovementEnding && d->vData.moving
+            && (!d->pressed && !d->stealMouse)) {
+        d->vData.moving = false;
+        d->vMoved = false;
+        emit movingVerticallyChanged();
+    }
+    if (wasMoving && !isMoving()) {
+        emit movingChanged();
+        emit movementEnded();
+#if QT_CONFIG(accessibility)
+        if (QAccessible::isActive()) {
+            QAccessibleEvent ev(this, QAccessible::ScrollingEnd);
+            QAccessible::updateAccessibility(&ev);
+        }
+#endif
+    }
+
+    if (hMovementEnding) {
+        d->hData.fixingUp = false;
+        d->hData.smoothVelocity.setValue(0);
+        d->hData.previousDragDelta = 0.0;
+    }
+    if (vMovementEnding) {
+        d->vData.fixingUp = false;
+        d->vData.smoothVelocity.setValue(0);
+        d->vData.previousDragDelta = 0.0;
+    }
+}
+
+void StretchFlickablePrivate::updateVelocity()
+{
+    Q_Q(StretchFlickable);
+    emit q->horizontalVelocityChanged();
+    emit q->verticalVelocityChanged();
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::horizontalOvershoot
+    \since 5.9
+
+    This property holds the horizontal overshoot, that is, the horizontal distance by
+    which the contents has been dragged or flicked past the bounds of the flickable.
+    The value is negative when the content is dragged or flicked beyond the beginning,
+    and positive when beyond the end; \c 0.0 otherwise.
+
+    Whether the values are reported for dragging and/or flicking is determined by
+    \l boundsBehavior. The overshoot distance is reported even when \l boundsMovement
+    is \c Flickable.StopAtBounds.
+
+    \sa verticalOvershoot, boundsBehavior, boundsMovement
+*/
+qreal StretchFlickable::horizontalOvershoot() const
+{
+    Q_D(const StretchFlickable);
+    return d->hData.overshoot;
+}
+
+/*!
+    \qmlproperty real QtQuick::Flickable::verticalOvershoot
+    \since 5.9
+
+    This property holds the vertical overshoot, that is, the vertical distance by
+    which the contents has been dragged or flicked past the bounds of the flickable.
+    The value is negative when the content is dragged or flicked beyond the beginning,
+    and positive when beyond the end; \c 0.0 otherwise.
+
+    Whether the values are reported for dragging and/or flicking is determined by
+    \l boundsBehavior. The overshoot distance is reported even when \l boundsMovement
+    is \c Flickable.StopAtBounds.
+
+    \sa horizontalOvershoot, boundsBehavior, boundsMovement
+*/
+qreal StretchFlickable::verticalOvershoot() const
+{
+    Q_D(const StretchFlickable);
+    return d->vData.overshoot;
+}
+
+/*!
+    \qmlproperty enumeration QtQuick::Flickable::boundsMovement
+    \since 5.10
+
+    This property holds whether the flickable will give a feeling that the edges of the
+    view are soft, rather than a hard physical boundary.
+
+    The \c boundsMovement can be one of:
+
+    \list
+    \li Flickable.StopAtBounds - this allows implementing custom edge effects where the
+    contents do not follow drags or flicks beyond the bounds of the flickable. The values
+    of \l horizontalOvershoot and \l verticalOvershoot can be utilized to implement custom
+    edge effects.
+    \li Flickable.FollowBoundsBehavior (default) - whether the contents follow drags or
+    flicks beyond the bounds of the flickable is determined by \l boundsBehavior.
+    \endlist
+
+    The following example keeps the contents within bounds and instead applies a flip
+    effect when flicked over horizontal bounds:
+    \code
+    Flickable {
+        id: flickable
+        boundsMovement: Flickable.StopAtBounds
+        boundsBehavior: Flickable.DragAndOvershootBounds
+        transform: Rotation {
+            axis { x: 0; y: 1; z: 0 }
+            origin.x: flickable.width / 2
+            origin.y: flickable.height / 2
+            angle: Math.min(30, Math.max(-30, flickable.horizontalOvershoot))
+        }
+    }
+    \endcode
+
+    The following example keeps the contents within bounds and instead applies an opacity
+    effect when dragged over vertical bounds:
+    \code
+    Flickable {
+        boundsMovement: Flickable.StopAtBounds
+        boundsBehavior: Flickable.DragOverBounds
+        opacity: Math.max(0.5, 1.0 - Math.abs(verticalOvershoot) / height)
+    }
+    \endcode
+
+    \sa boundsBehavior, verticalOvershoot, horizontalOvershoot
+*/
+StretchFlickable::BoundsMovement StretchFlickable::boundsMovement() const
+{
+    Q_D(const StretchFlickable);
+    return d->boundsMovement;
+}
+
+void StretchFlickable::setBoundsMovement(BoundsMovement movement)
+{
+    Q_D(StretchFlickable);
+    if (d->boundsMovement == movement)
+        return;
+
+    d->boundsMovement = movement;
+    emit boundsMovementChanged();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_stretchflickable_p_p.cpp"
+
+#include "moc_stretchflickable_p.cpp"
diff --git a/src/stretchflickable_p.h b/src/stretchflickable_p.h
new file mode 100644
index 0000000..9889721
--- /dev/null
+++ b/src/stretchflickable_p.h
@@ -0,0 +1,311 @@
+// Copyright (C) 2019 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef STRETCHFLICKABLE_P_H
+#define STRETCHFLICKABLE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qquickitem.h>
+#include <private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class StretchFlickablePrivate;
+class StretchFlickableVisibleArea;
+class QPointerEvent;
+class StretchFlickable : public QQuickItem
+{
+    Q_OBJECT
+
+    Q_PROPERTY(qreal contentWidth READ contentWidth WRITE setContentWidth NOTIFY contentWidthChanged)
+    Q_PROPERTY(qreal contentHeight READ contentHeight WRITE setContentHeight NOTIFY contentHeightChanged)
+    Q_PROPERTY(qreal contentX READ contentX WRITE setContentX NOTIFY contentXChanged)
+    Q_PROPERTY(qreal contentY READ contentY WRITE setContentY NOTIFY contentYChanged)
+    Q_PROPERTY(QQuickItem *contentItem READ contentItem CONSTANT)
+
+    Q_PROPERTY(qreal topMargin READ topMargin WRITE setTopMargin NOTIFY topMarginChanged)
+    Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin NOTIFY bottomMarginChanged)
+    Q_PROPERTY(qreal originY READ originY NOTIFY originYChanged)
+
+    Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin NOTIFY leftMarginChanged)
+    Q_PROPERTY(qreal rightMargin READ rightMargin WRITE setRightMargin NOTIFY rightMarginChanged)
+    Q_PROPERTY(qreal originX READ originX NOTIFY originXChanged)
+
+    Q_PROPERTY(qreal horizontalVelocity READ horizontalVelocity NOTIFY horizontalVelocityChanged)
+    Q_PROPERTY(qreal verticalVelocity READ verticalVelocity NOTIFY verticalVelocityChanged)
+
+    Q_PROPERTY(BoundsBehavior boundsBehavior READ boundsBehavior WRITE setBoundsBehavior NOTIFY boundsBehaviorChanged)
+    Q_PROPERTY(BoundsMovement boundsMovement READ boundsMovement WRITE setBoundsMovement NOTIFY boundsMovementChanged)
+    Q_PROPERTY(QQuickTransition *rebound READ rebound WRITE setRebound NOTIFY reboundChanged)
+    Q_PROPERTY(qreal maximumFlickVelocity READ maximumFlickVelocity WRITE setMaximumFlickVelocity NOTIFY maximumFlickVelocityChanged)
+    Q_PROPERTY(qreal flickDeceleration READ flickDeceleration WRITE setFlickDeceleration NOTIFY flickDecelerationChanged)
+    // characteristic drag distance (in px) of the progressive overshoot
+    // resistance curve: small overshoots track the finger closely, larger
+    // ones increasingly resist, asymptoting as the drag approaches this range
+    Q_PROPERTY(qreal dragResistanceRange READ dragResistanceRange WRITE setDragResistanceRange NOTIFY dragResistanceRangeChanged)
+    // hard cap (in px) on how far drag-over-bounds can stretch the content -
+    // the drag never visually overshoots past this, no matter how far you pull
+    Q_PROPERTY(qreal dragOvershootMax READ dragOvershootMax WRITE setDragOvershootMax NOTIFY dragOvershootMaxChanged)
+    Q_PROPERTY(bool moving READ isMoving NOTIFY movingChanged)
+    Q_PROPERTY(bool movingHorizontally READ isMovingHorizontally NOTIFY movingHorizontallyChanged)
+    Q_PROPERTY(bool movingVertically READ isMovingVertically NOTIFY movingVerticallyChanged)
+    Q_PROPERTY(bool flicking READ isFlicking NOTIFY flickingChanged)
+    Q_PROPERTY(bool flickingHorizontally READ isFlickingHorizontally NOTIFY flickingHorizontallyChanged)
+    Q_PROPERTY(bool flickingVertically READ isFlickingVertically NOTIFY flickingVerticallyChanged)
+    Q_PROPERTY(bool dragging READ isDragging NOTIFY draggingChanged)
+    Q_PROPERTY(bool draggingHorizontally READ isDraggingHorizontally NOTIFY draggingHorizontallyChanged)
+    Q_PROPERTY(bool draggingVertically READ isDraggingVertically NOTIFY draggingVerticallyChanged)
+    Q_PROPERTY(FlickableDirection flickableDirection READ flickableDirection WRITE setFlickableDirection NOTIFY flickableDirectionChanged)
+
+    Q_PROPERTY(bool interactive READ isInteractive WRITE setInteractive NOTIFY interactiveChanged)
+    Q_PROPERTY(int pressDelay READ pressDelay WRITE setPressDelay NOTIFY pressDelayChanged)
+
+    Q_PROPERTY(bool atXEnd READ isAtXEnd NOTIFY atXEndChanged)
+    Q_PROPERTY(bool atYEnd READ isAtYEnd NOTIFY atYEndChanged)
+    Q_PROPERTY(bool atXBeginning READ isAtXBeginning NOTIFY atXBeginningChanged)
+    Q_PROPERTY(bool atYBeginning READ isAtYBeginning NOTIFY atYBeginningChanged)
+
+    Q_PROPERTY(StretchFlickableVisibleArea *visibleArea READ visibleArea CONSTANT)
+
+    Q_PROPERTY(bool pixelAligned READ pixelAligned WRITE setPixelAligned NOTIFY pixelAlignedChanged)
+    Q_PROPERTY(bool synchronousDrag READ synchronousDrag WRITE setSynchronousDrag NOTIFY synchronousDragChanged)
+
+    Q_PROPERTY(qreal horizontalOvershoot READ horizontalOvershoot NOTIFY horizontalOvershootChanged)
+    Q_PROPERTY(qreal verticalOvershoot READ verticalOvershoot NOTIFY verticalOvershootChanged)
+
+    Q_PROPERTY(Qt::MouseButtons acceptedButtons READ acceptedButtons WRITE setAcceptedButtons NOTIFY acceptedButtonsChanged FINAL)
+
+    Q_PROPERTY(QQmlListProperty<QObject> flickableData READ flickableData)
+    Q_PROPERTY(QQmlListProperty<QQuickItem> flickableChildren READ flickableChildren)
+    Q_CLASSINFO("DefaultProperty", "flickableData")
+    QML_NAMED_ELEMENT(StretchFlickable)
+
+public:
+    StretchFlickable(QQuickItem *parent=nullptr);
+    ~StretchFlickable() override;
+
+    QQmlListProperty<QObject> flickableData();
+    QQmlListProperty<QQuickItem> flickableChildren();
+
+    enum BoundsBehaviorFlag {
+        StopAtBounds = 0x0,
+        DragOverBounds = 0x1,
+        OvershootBounds = 0x2,
+        DragAndOvershootBounds = DragOverBounds | OvershootBounds
+    };
+    Q_DECLARE_FLAGS(BoundsBehavior, BoundsBehaviorFlag)
+    Q_FLAG(BoundsBehavior)
+
+    BoundsBehavior boundsBehavior() const;
+    void setBoundsBehavior(BoundsBehavior);
+
+    enum BoundsMovement {
+        // StopAtBounds = 0x0,
+        FollowBoundsBehavior = 0x1
+    };
+    Q_ENUM(BoundsMovement)
+
+    BoundsMovement boundsMovement() const;
+    void setBoundsMovement(BoundsMovement movement);
+
+    QQuickTransition *rebound() const;
+    void setRebound(QQuickTransition *transition);
+
+    qreal contentWidth() const;
+    void setContentWidth(qreal);
+
+    qreal contentHeight() const;
+    void setContentHeight(qreal);
+
+    qreal contentX() const;
+    virtual void setContentX(qreal pos);
+
+    qreal contentY() const;
+    virtual void setContentY(qreal pos);
+
+    qreal topMargin() const;
+    void setTopMargin(qreal m);
+
+    qreal bottomMargin() const;
+    void setBottomMargin(qreal m);
+
+    qreal leftMargin() const;
+    void setLeftMargin(qreal m);
+
+    qreal rightMargin() const;
+    void setRightMargin(qreal m);
+
+    virtual qreal originY() const;
+    virtual qreal originX() const;
+
+    bool isMoving() const;
+    bool isMovingHorizontally() const;
+    bool isMovingVertically() const;
+    bool isFlicking() const;
+    bool isFlickingHorizontally() const;
+    bool isFlickingVertically() const;
+    bool isDragging() const;
+    bool isDraggingHorizontally() const;
+    bool isDraggingVertically() const;
+
+    int pressDelay() const;
+    void setPressDelay(int delay);
+
+    qreal maximumFlickVelocity() const;
+    void setMaximumFlickVelocity(qreal);
+
+    qreal flickDeceleration() const;
+    void setFlickDeceleration(qreal);
+
+    qreal dragResistanceRange() const;
+    void setDragResistanceRange(qreal);
+
+    qreal dragOvershootMax() const;
+    void setDragOvershootMax(qreal);
+
+    bool isInteractive() const;
+    void setInteractive(bool);
+
+    qreal horizontalVelocity() const;
+    qreal verticalVelocity() const;
+
+    bool isAtXEnd() const;
+    bool isAtXBeginning() const;
+    bool isAtYEnd() const;
+    bool isAtYBeginning() const;
+
+    QQuickItem *contentItem() const;
+
+    enum FlickableDirection { AutoFlickDirection=0x0, HorizontalFlick=0x1, VerticalFlick=0x2, HorizontalAndVerticalFlick=0x3,
+                              AutoFlickIfNeeded=0xc };
+    Q_ENUM(FlickableDirection)
+    FlickableDirection flickableDirection() const;
+    void setFlickableDirection(FlickableDirection);
+
+    bool pixelAligned() const;
+    void setPixelAligned(bool align);
+
+    bool synchronousDrag() const;
+    void setSynchronousDrag(bool v);
+
+    Qt::MouseButtons acceptedButtons() const;
+    void setAcceptedButtons(Qt::MouseButtons buttons);
+
+    qreal horizontalOvershoot() const;
+    qreal verticalOvershoot() const;
+
+    Q_INVOKABLE void resizeContent(qreal w, qreal h, QPointF center);
+    Q_INVOKABLE void returnToBounds();
+    Q_INVOKABLE void flick(qreal xVelocity, qreal yVelocity);
+    Q_INVOKABLE void cancelFlick();
+
+Q_SIGNALS:
+    void contentWidthChanged();
+    void contentHeightChanged();
+    void contentXChanged();
+    void contentYChanged();
+    void topMarginChanged();
+    void bottomMarginChanged();
+    void leftMarginChanged();
+    void rightMarginChanged();
+    void originYChanged();
+    void originXChanged();
+    void movingChanged();
+    void movingHorizontallyChanged();
+    void movingVerticallyChanged();
+    void flickingChanged();
+    void flickingHorizontallyChanged();
+    void flickingVerticallyChanged();
+    void draggingChanged();
+    void draggingHorizontallyChanged();
+    void draggingVerticallyChanged();
+    void horizontalVelocityChanged();
+    void verticalVelocityChanged();
+    void isAtBoundaryChanged();
+    void flickableDirectionChanged();
+    void interactiveChanged();
+    void boundsBehaviorChanged();
+    void boundsMovementChanged();
+    void reboundChanged();
+    void maximumFlickVelocityChanged();
+    void flickDecelerationChanged();
+    void dragResistanceRangeChanged();
+    void dragOvershootMaxChanged();
+    void pressDelayChanged();
+    void movementStarted();
+    void movementEnded();
+    void flickStarted();
+    void flickEnded();
+    void dragStarted();
+    void dragEnded();
+    void pixelAlignedChanged();
+    void synchronousDragChanged();
+    void horizontalOvershootChanged();
+    void verticalOvershootChanged();
+
+    void atXEndChanged();
+    void atYEndChanged();
+    void atXBeginningChanged();
+    void atYBeginningChanged();
+
+    void acceptedButtonsChanged();
+
+protected:
+    bool childMouseEventFilter(QQuickItem *, QEvent *) override;
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+    void touchEvent(QTouchEvent *event) override;
+#if QT_CONFIG(wheelevent)
+    void wheelEvent(QWheelEvent *event) override;
+#endif
+    void timerEvent(QTimerEvent *event) override;
+
+    StretchFlickableVisibleArea *visibleArea();
+
+protected Q_SLOTS:
+    void movementStarting();
+    void movementEnding();
+    void movementEnding(bool hMovementEnding, bool vMovementEnding);
+    void velocityTimelineCompleted();
+    void timelineCompleted();
+
+protected:
+    virtual qreal minXExtent() const;
+    virtual qreal minYExtent() const;
+    virtual qreal maxXExtent() const;
+    virtual qreal maxYExtent() const;
+    qreal vWidth() const;
+    qreal vHeight() const;
+    void componentComplete() override;
+    virtual void viewportMoved(Qt::Orientations orient);
+    void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override;
+    void mouseUngrabEvent() override;
+    bool filterPointerEvent(QQuickItem *receiver, QPointerEvent *event);
+
+    bool xflick() const;
+    bool yflick() const;
+
+protected:
+    StretchFlickable(StretchFlickablePrivate &dd, QQuickItem *parent);
+
+private:
+    Q_DISABLE_COPY(StretchFlickable)
+    Q_DECLARE_PRIVATE(StretchFlickable)
+    friend class StretchFlickableVisibleArea;
+    friend class StretchFlickableReboundTransition;
+};
+
+QT_END_NAMESPACE
+
+#endif // STRETCHFLICKABLE_P_H
diff --git a/src/stretchflickable_p_p.h b/src/stretchflickable_p_p.h
new file mode 100644
index 0000000..08242c7
--- /dev/null
+++ b/src/stretchflickable_p_p.h
@@ -0,0 +1,300 @@
+// Copyright (C) 2019 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef STRETCHFLICKABLE_P_P_H
+#define STRETCHFLICKABLE_P_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "stretchflickable_p.h"
+#include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickitemchangelistener_p.h>
+
+#include <QtQml/qqml.h>
+#include <QtCore/qdatetime.h>
+
+#include "stretchtimeline_p_p.h"
+#include <private/qquickanimation_p_p.h>
+#include <private/qquicktransitionmanager_p_p.h>
+#include <private/qpodvector_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class StretchFlickableVisibleArea;
+class QQuickTransition;
+class StretchFlickableReboundTransition;
+
+class StretchFlickablePrivate : public QQuickItemPrivate,
+                                              public QSafeQuickItemChangeListener<StretchFlickablePrivate>
+{
+    Q_DECLARE_PUBLIC(StretchFlickable)
+
+public:
+    static inline StretchFlickablePrivate *get(StretchFlickable *o) { return o->d_func(); }
+
+    StretchFlickablePrivate();
+    void init();
+
+    struct Velocity : public StretchTimeLineValue
+    {
+        Velocity(StretchFlickablePrivate *p)
+            : parent(p) {}
+        void setValue(qreal v) override {
+            if (v != value()) {
+                StretchTimeLineValue::setValue(v);
+                parent->updateVelocity();
+            }
+        }
+        StretchFlickablePrivate *parent;
+    };
+
+    enum MovementReason { Other, SetIndex, Mouse };
+
+    struct AxisData {
+        AxisData(StretchFlickablePrivate *fp, void (StretchFlickablePrivate::*func)(qreal))
+            : move(fp, func)
+            , smoothVelocity(fp), atEnd(false), atBeginning(true)
+            , transitionToSet(false)
+            , fixingUp(false), inOvershoot(false), inRebound(false), moving(false), flicking(false)
+            , flickingWhenDragBegan(false), dragging(false), extentsChanged(false)
+            , explicitValue(false), contentPositionChangedExternallyDuringDrag(false)
+            , minExtentDirty(true), maxExtentDirty(true)
+        {}
+
+        ~AxisData();
+
+        void reset() {
+            velocityBuffer.clear();
+            dragStartOffset = 0;
+            fixingUp = false;
+            inOvershoot = false;
+            contentPositionChangedExternallyDuringDrag = false;
+        }
+
+        void markExtentsDirty() {
+            minExtentDirty = true;
+            maxExtentDirty = true;
+            extentsChanged = true;
+        }
+
+        void resetTransitionTo() {
+            transitionTo = 0;
+            transitionToSet = false;
+        }
+
+        void addVelocitySample(qreal v, qreal maxVelocity);
+        void updateVelocity();
+
+        StretchTimeLineValueProxy<StretchFlickablePrivate> move;
+        StretchFlickableReboundTransition *transitionToBounds = nullptr;
+        qreal viewSize = -1;
+        qreal pressPos = 0;
+        qreal lastPos = 0;
+        qreal dragStartOffset = 0;
+        qreal dragMinBound = 0;
+        qreal dragMaxBound = 0;
+        qreal previousDragDelta = 0;
+        qreal velocity = 0;
+        qreal flickTarget = 0;
+        qreal startMargin = 0;
+        qreal endMargin = 0;
+        qreal origin = 0;
+        qreal overshoot = 0;
+        qreal transitionTo = 0;
+        qreal continuousFlickVelocity = 0;
+        QElapsedTimer velocityTime;
+        int vTime = 0;
+        StretchFlickablePrivate::Velocity smoothVelocity;
+        QPODVector<qreal,10> velocityBuffer;
+        // bitfield
+        uint atEnd : 1;
+        uint atBeginning : 1;
+        uint transitionToSet : 1;
+        uint fixingUp : 1;
+        uint inOvershoot : 1;
+        uint inRebound : 1;
+        uint moving : 1;
+        uint flicking : 1;
+        uint flickingWhenDragBegan : 1;
+        uint dragging : 1;
+        uint extentsChanged : 1;
+        uint explicitValue : 1;
+        uint contentPositionChangedExternallyDuringDrag : 1;
+        // mutable portion of bitfield
+        mutable uint minExtentDirty : 1;
+        mutable uint maxExtentDirty : 1;
+        // end bitfield
+    };
+
+    bool flickX(QEvent::Type eventType, qreal velocity);
+    bool flickY(QEvent::Type eventType, qreal velocity);
+    virtual bool flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,
+                       StretchTimeLineCallback::Callback fixupCallback,
+                       QEvent::Type eventType, qreal velocity);
+    void flickingStarted(bool flickingH, bool flickingV);
+
+    void fixupX();
+    void fixupY();
+    virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);
+    void adjustContentPos(AxisData &data, qreal toPos);
+    void resetTimeline(AxisData &data);
+    void clearTimeline();
+
+    void updateBeginningEnd();
+
+    bool isInnermostPressDelay(QQuickItem *item) const;
+    void captureDelayedPress(QQuickItem *item, QPointerEvent *event);
+    void clearDelayedPress();
+    void replayDelayedPress();
+
+    void setViewportX(qreal x);
+    void setViewportY(qreal y);
+
+    qreal overShootDistance(qreal velocity) const;
+
+    // characteristic distance (in device pixels) of the progressive drag
+    // resistance curve used in drag() - see StretchFlickable::dragResistanceRange.
+    // Large by design: dragging the full distance only gets you partway to
+    // dragOvershootMax, which is what makes the resistance feel "heavy".
+    qreal dragOvershootRange() const;
+    qreal dragResistanceRange = 600;
+
+    // hard cap (in device pixels) on how far drag-over-bounds can stretch
+    // the content - see StretchFlickable::dragOvershootMax
+    qreal dragOvershootMaxPixels() const;
+    qreal dragOvershootMax = 50;
+
+    void itemGeometryChanged(QQuickItem *, QQuickGeometryChange, const QRectF &) override;
+
+    void draggingStarting();
+    void draggingEnding();
+
+    bool isViewMoving() const;
+
+    void cancelInteraction();
+
+    void addPointerHandler(QQuickPointerHandler *h) override;
+
+    virtual bool wantsPointerEvent(const QPointerEvent *) { return true; }
+
+public:
+    QQuickItem *contentItem;
+
+    AxisData hData;
+    AxisData vData;
+
+    MovementReason moveReason = Other;
+
+    StretchTimeLine timeline;
+    bool hMoved : 1;
+    bool vMoved : 1;
+    bool stealMouse : 1;
+    bool pressed : 1;
+    bool scrollingPhase : 1;
+    bool interactive : 1;
+    bool calcVelocity : 1;
+    bool pixelAligned : 1;
+    bool syncDrag : 1;
+    Qt::MouseButtons acceptedButtons = Qt::LeftButton;
+    QElapsedTimer timer;
+    qint64 lastPosTime;
+    qint64 lastPressTime;
+    QPointF lastPos;
+    QPointF pressPos;
+    QVector2D accumulatedWheelPixelDelta;
+    qreal deceleration;
+    qreal wheelDeceleration;
+    qreal maxVelocity;
+    QPointerEvent *delayedPressEvent;
+    QBasicTimer delayedPressTimer;
+    int pressDelay;
+    int fixupDuration;
+    qreal flickBoost;
+    qreal initialWheelFlickDistance;
+
+    enum FixupMode { Normal, Immediate, ExtentChanged };
+    FixupMode fixupMode;
+
+    static void fixupY_callback(void *);
+    static void fixupX_callback(void *);
+
+    void updateVelocity();
+    int vTime;
+    StretchTimeLine velocityTimeline;
+    StretchFlickableVisibleArea *visibleArea;
+    StretchFlickable::FlickableDirection flickableDirection;
+    StretchFlickable::BoundsBehavior boundsBehavior;
+    StretchFlickable::BoundsMovement boundsMovement;
+    QQuickTransition *rebound;
+
+    void viewportAxisMoved(AxisData &data, qreal minExtent, qreal maxExtent,
+                       StretchTimeLineCallback::Callback fixupCallback);
+
+    void handlePressEvent(QPointerEvent *);
+    void handleMoveEvent(QPointerEvent *);
+    void handleReleaseEvent(QPointerEvent *);
+    bool buttonsAccepted(const QSinglePointEvent *event);
+
+    void maybeBeginDrag(qint64 currentTimestamp, const QPointF &pressPosn,
+                        Qt::MouseButtons buttons = Qt::NoButton);
+    void drag(qint64 currentTimestamp, QEvent::Type eventType, const QPointF &localPos,
+              const QVector2D &deltas, bool overThreshold, bool momentum,
+              bool velocitySensitiveOverBounds, const QVector2D &velocity);
+
+    QVector2D firstPointLocalVelocity(QPointerEvent *event);
+    qint64 computeCurrentTime(QInputEvent *event) const;
+    qreal devicePixelRatio() const;
+
+    // flickableData property
+    static void data_append(QQmlListProperty<QObject> *, QObject *);
+    static qsizetype data_count(QQmlListProperty<QObject> *);
+    static QObject *data_at(QQmlListProperty<QObject> *, qsizetype);
+    static void data_clear(QQmlListProperty<QObject> *);
+};
+
+class StretchFlickableVisibleArea : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(qreal xPosition READ xPosition NOTIFY xPositionChanged FINAL)
+    Q_PROPERTY(qreal yPosition READ yPosition NOTIFY yPositionChanged FINAL)
+    Q_PROPERTY(qreal widthRatio READ widthRatio NOTIFY widthRatioChanged FINAL)
+    Q_PROPERTY(qreal heightRatio READ heightRatio NOTIFY heightRatioChanged FINAL)
+    QML_ANONYMOUS
+
+public:
+    StretchFlickableVisibleArea(StretchFlickable *parent=nullptr);
+
+    qreal xPosition() const;
+    qreal widthRatio() const;
+    qreal yPosition() const;
+    qreal heightRatio() const;
+
+    void updateVisible();
+
+Q_SIGNALS:
+    void xPositionChanged(qreal xPosition);
+    void yPositionChanged(qreal yPosition);
+    void widthRatioChanged(qreal widthRatio);
+    void heightRatioChanged(qreal heightRatio);
+
+private:
+    StretchFlickable *flickable;
+    qreal m_xPosition;
+    qreal m_widthRatio;
+    qreal m_yPosition;
+    qreal m_heightRatio;
+};
+
+QT_END_NAMESPACE
+
+#endif // STRETCHFLICKABLE_P_P_H
diff --git a/src/stretchflickablebehavior_p.h b/src/stretchflickablebehavior_p.h
new file mode 100644
index 0000000..9d95aa1
--- /dev/null
+++ b/src/stretchflickablebehavior_p.h
@@ -0,0 +1,72 @@
+// Copyright (C) 2016 Research In Motion.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef STRETCHFLICKABLEBEHAVIOR_H
+#define STRETCHFLICKABLEBEHAVIOR_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+/* ### Platform specific flickable mechanics are defined either here, or in
+       mkspec files. Long-term (QtQuick 3) Flickable needs to allow such
+       mechanic details to be controlled via QML so that platforms can easily
+       load custom behavior at QML compile time.
+*/
+
+// The maximum number of pixels a flick can overshoot
+#ifndef QML_FLICK_OVERSHOOT
+#define QML_FLICK_OVERSHOOT 150
+#endif
+
+// The number of samples to use in calculating the velocity of a flick
+#ifndef QML_FLICK_SAMPLEBUFFER
+#define QML_FLICK_SAMPLEBUFFER 3
+#endif
+
+// The number of samples to discard when calculating the flick velocity.
+// Touch panels often produce inaccurate results as the finger is lifted.
+#ifndef QML_FLICK_DISCARDSAMPLES
+#define QML_FLICK_DISCARDSAMPLES 0
+#endif
+
+// How much faster to decelerate when overshooting
+#ifndef QML_FLICK_OVERSHOOTFRICTION
+#define QML_FLICK_OVERSHOOTFRICTION 8
+#endif
+
+// Multiflick acceleration minimum flick velocity threshold
+#ifndef QML_FLICK_MULTIFLICK_THRESHOLD
+#define QML_FLICK_MULTIFLICK_THRESHOLD 1250
+#endif
+
+// If the time (ms) between the last move and the release exceeds this, then velocity will be zero.
+#ifndef QML_FLICK_VELOCITY_DECAY_TIME
+#define QML_FLICK_VELOCITY_DECAY_TIME 50
+#endif
+
+// Multiflick acceleration minimum contentSize/viewSize ratio
+#ifndef QML_FLICK_MULTIFLICK_RATIO
+#define QML_FLICK_MULTIFLICK_RATIO 10
+#endif
+
+// Multiflick acceleration maximum velocity multiplier
+#ifndef QML_FLICK_MULTIFLICK_MAXBOOST
+#define QML_FLICK_MULTIFLICK_MAXBOOST 3.0
+#endif
+
+// Really slow flicks can be annoying.
+const qreal _q_MinimumFlickVelocity = 75.0;
+
+// If StretchFlickablePrivate::wheelDeceleration (perhaps overridden via QT_QUICK_FLICKABLE_WHEEL_DECELERATION)
+// is greater than this, we switch to proportional wheel scrolling: no "acceleration" at all.
+const qreal _q_MaximumWheelDeceleration = 14999;
+
+#endif //STRETCHFLICKABLEBEHAVIOR_H
diff --git a/src/stretchtimeline.cpp b/src/stretchtimeline.cpp
new file mode 100644
index 0000000..81c7622
--- /dev/null
+++ b/src/stretchtimeline.cpp
@@ -0,0 +1,931 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "stretchtimeline_p_p.h"
+
+#include <QDebug>
+#include <QMutex>
+#include <QThread>
+#include <QWaitCondition>
+#include <QEvent>
+#include <QCoreApplication>
+#include <QEasingCurve>
+#include <QTime>
+#include <QtCore/private/qnumeric_p.h>
+#include <QHash>
+
+#include <algorithm>
+
+QT_BEGIN_NAMESPACE
+
+Q_STATIC_LOGGING_CATEGORY(lcTl, "qt.quick.timeline")
+
+struct Update {
+    Update(StretchTimeLineValue *_g, qreal _v)
+        : g(_g), v(_v) {}
+    Update(const StretchTimeLineCallback &_e)
+        : g(nullptr), v(0), e(_e) {}
+
+    StretchTimeLineValue *g;
+    qreal v;
+    StretchTimeLineCallback e;
+};
+
+struct StretchTimeLinePrivate
+{
+    StretchTimeLinePrivate(StretchTimeLine *);
+
+    struct Op {
+        enum Type {
+            Pause, // Pauses any value updates
+            Set, // Instantly changes the value to a target value
+            Move, // Moves towards a target value over time
+            MoveBy, // Same as Move, but target value is now an offset from the starting value
+            Accel, // Moves towards a target value over time with a constant acceleration
+            AccelDistance,
+            Execute // Calls back a function
+        };
+        Op() {}
+        Op(Type t, int l, qreal v, qreal v2, int o,
+           const StretchTimeLineCallback &ev = StretchTimeLineCallback(), const QEasingCurve &es = QEasingCurve())
+            : type(t), length(l), value(v), value2(v2), order(o), event(ev),
+              easing(es) {}
+        Op(const Op &o)
+            : type(o.type), length(o.length), value(o.value), value2(o.value2),
+              order(o.order), event(o.event), easing(o.easing) {}
+        Op &operator=(const Op &o) {
+            type = o.type; length = o.length; value = o.value;
+            value2 = o.value2; order = o.order; event = o.event;
+            easing = o.easing;
+            return *this;
+        }
+
+        Type type;
+        int length;
+        qreal value;
+        qreal value2;
+
+        int order;
+        StretchTimeLineCallback event;
+        QEasingCurve easing;
+    };
+    struct TimeLine
+    {
+        TimeLine() {}
+        QList<Op> ops;
+        int length = 0;
+        int consumedOpLength = 0;
+        qreal base = 0.;
+    };
+
+    int length;
+    int syncPoint;
+    typedef QHash<StretchTimeLineObject *, TimeLine> Ops;
+    Ops ops;
+    StretchTimeLine *q;
+
+    void add(StretchTimeLineObject &, const Op &);
+    qreal value(const Op &op, int time, qreal base, bool *) const;
+
+    int advance(int);
+
+    bool clockRunning;
+    int prevTime;
+
+    int order;
+
+    StretchTimeLine::SyncMode syncMode;
+    int syncAdj;
+    QList<QPair<int, Update> > *updateQueue;
+};
+
+StretchTimeLinePrivate::StretchTimeLinePrivate(StretchTimeLine *parent)
+: length(0), syncPoint(0), q(parent), clockRunning(false), prevTime(0), order(0), syncMode(StretchTimeLine::LocalSync), syncAdj(0), updateQueue(nullptr)
+{
+}
+
+void StretchTimeLinePrivate::add(StretchTimeLineObject &g, const Op &o)
+{
+    if (g._t && g._t != q) {
+        qWarning() << "StretchTimeLine: Cannot modify a StretchTimeLineValue owned by"
+                   << "another timeline.";
+        return;
+    }
+    g._t = q;
+
+    Ops::Iterator iter = ops.find(&g);
+    if (iter == ops.end()) {
+        iter = ops.insert(&g, TimeLine());
+        if (syncPoint > 0)
+            q->pause(g, syncPoint);
+    }
+    if (!iter->ops.isEmpty() &&
+       o.type == Op::Pause &&
+       iter->ops.constLast().type == Op::Pause) {
+        // If the last operation was a pause, and we're adding another, simply prolong it.
+        iter->ops.last().length += o.length;
+        iter->length += o.length;
+    } else {
+        // Add to the list of operations
+        iter->ops.append(o);
+        iter->length += o.length;
+    }
+
+    if (iter->length > length)
+        length = iter->length;
+
+    if (!clockRunning) {
+        q->stop();
+        prevTime = 0;
+        clockRunning = true;
+
+        if (syncMode == StretchTimeLine::LocalSync)  {
+            syncAdj = -1;
+        } else {
+            syncAdj = 0;
+        }
+        q->start();
+/*        q->tick(0);
+        if (syncMode == StretchTimeLine::LocalSync)  {
+            syncAdj = -1;
+        } else {
+            syncAdj = 0;
+        }
+        */
+    }
+}
+
+qreal StretchTimeLinePrivate::value(const Op &op, int time, qreal base, bool *changed) const
+{
+    Q_ASSERT(time >= 0);
+    Q_ASSERT(time <= op.length);
+    *changed = true;
+
+    switch(op.type) {
+        case Op::Pause:
+            *changed = false;
+            return base;
+        case Op::Set:
+            return op.value;
+        case Op::Move:
+            if (time == 0) {
+                return base;
+            } else if (time == (op.length)) {
+                return op.value;
+            } else {
+                qreal delta = op.value - base;
+                qreal pTime = (qreal)(time) / (qreal)op.length;
+                if (op.easing.type() == QEasingCurve::Linear)
+                    return base + delta * pTime;
+                else
+                    return base + delta * op.easing.valueForProgress(pTime);
+            }
+        case Op::MoveBy:
+            if (time == 0) {
+                return base;
+            } else if (time == (op.length)) {
+                return base + op.value;
+            } else {
+                qreal delta = op.value;
+                qreal pTime = (qreal)(time) / (qreal)op.length;
+                if (op.easing.type() == QEasingCurve::Linear)
+                    return base + delta * pTime;
+                else
+                    return base + delta * op.easing.valueForProgress(pTime);
+            }
+        case Op::Accel:
+            if (time == 0) {
+                return base;
+            } else {
+                qreal t = (qreal)(time) / 1000.0f;
+                qreal delta = op.value * t + 0.5f * op.value2 * t * t;
+                return base + delta;
+            }
+        case Op::AccelDistance:
+            if (time == 0) {
+                return base;
+            } else if (time == (op.length)) {
+                return base + op.value2;
+            } else {
+                qreal t = (qreal)(time) / 1000.0f;
+                qreal accel = -1.0f * 1000.0f * op.value / (qreal)op.length;
+                qreal delta = op.value * t + 0.5f * accel * t * t;
+                return base + delta;
+
+            }
+        case Op::Execute:
+            op.event.d0(op.event.d1);
+            *changed = false;
+            return -1;
+    }
+
+    return base;
+}
+
+/*!
+    \internal
+    \class StretchTimeLine
+    \brief The StretchTimeLine class provides a timeline for controlling animations.
+
+    StretchTimeLine is similar to QTimeLine except:
+    \list
+    \li It updates StretchTimeLineValue instances directly, rather than maintaining a single
+    current value.
+
+    For example, the following animates a simple value over 200 milliseconds:
+    \code
+    StretchTimeLineValue v(<starting value>);
+    StretchTimeLine tl;
+    tl.move(v, 100., 200);
+    tl.start()
+    \endcode
+
+    If your program needs to know when values are changed, it can either
+    connect to the StretchTimeLine's updated() signal, or inherit from StretchTimeLineValue
+    and reimplement the StretchTimeLineValue::setValue() method.
+
+    \li Supports multiple StretchTimeLineValue, arbitrary start and end values and allows
+    animations to be strung together for more complex effects.
+
+    For example, the following animation moves the x and y coordinates of
+    an object from wherever they are to the position (100, 100) in 50
+    milliseconds and then further animates them to (100, 200) in 50
+    milliseconds:
+
+    \code
+    StretchTimeLineValue x(<starting value>);
+    StretchTimeLineValue y(<starting value>);
+
+    StretchTimeLine tl;
+    tl.start();
+
+    tl.move(x, 100., 50);
+    tl.move(y, 100., 50);
+    tl.move(y, 200., 50);
+    \endcode
+
+    \li All StretchTimeLine instances share a single, synchronized clock.
+
+    Actions scheduled within the same event loop tick are scheduled
+    synchronously against each other, regardless of the wall time between the
+    scheduling.  Synchronized scheduling applies both to within the same
+    StretchTimeLine and across separate StretchTimeLine's within the same process.
+
+    \endlist
+
+    Currently easing functions are not supported.
+*/
+
+
+/*!
+    Construct a new StretchTimeLine with the specified \a parent.
+*/
+StretchTimeLine::StretchTimeLine(QObject *parent)
+    : QObject(parent)
+{
+    d = new StretchTimeLinePrivate(this);
+}
+
+/*!
+    Destroys the time line.  Any inprogress animations are canceled, but not
+    completed.
+*/
+StretchTimeLine::~StretchTimeLine()
+{
+    for (StretchTimeLinePrivate::Ops::Iterator iter = d->ops.begin();
+            iter != d->ops.end();
+            ++iter)
+        iter.key()->_t = nullptr;
+
+    delete d; d = nullptr;
+}
+
+/*!
+    \enum StretchTimeLine::SyncMode
+ */
+
+/*!
+    Return the timeline's synchronization mode.
+ */
+StretchTimeLine::SyncMode StretchTimeLine::syncMode() const
+{
+    return d->syncMode;
+}
+
+/*!
+    Set the timeline's synchronization mode to \a syncMode.
+ */
+void StretchTimeLine::setSyncMode(SyncMode syncMode)
+{
+    d->syncMode = syncMode;
+}
+
+/*!
+    Pause \a obj for \a time milliseconds.
+*/
+void StretchTimeLine::pause(StretchTimeLineObject &obj, int time)
+{
+    if (time <= 0) return;
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Pause, time, 0., 0., d->order++);
+    d->add(obj, op);
+}
+
+/*!
+    Execute the \a event.
+ */
+void StretchTimeLine::callback(const StretchTimeLineCallback &callback)
+{
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Execute, 0, 0, 0., d->order++, callback);
+    d->add(*callback.callbackObject(), op);
+}
+
+/*!
+    Set the \a value of \a timeLineValue.
+*/
+void StretchTimeLine::set(StretchTimeLineValue &timeLineValue, qreal value)
+{
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Set, 0, value, 0., d->order++);
+    d->add(timeLineValue, op);
+}
+
+/*!
+    Decelerate \a timeLineValue from the starting \a velocity to zero at the
+    given \a acceleration rate.  Although the \a acceleration is technically
+    a deceleration, it should always be positive.  The StretchTimeLine will ensure
+    that the deceleration is in the opposite direction to the initial velocity.
+*/
+int StretchTimeLine::accel(StretchTimeLineValue &timeLineValue, qreal velocity, qreal acceleration)
+{
+    if (qFuzzyIsNull(acceleration) || qt_is_nan(acceleration))
+        return -1;
+
+    if ((velocity > 0.0f) == (acceleration > 0.0f))
+        acceleration = acceleration * -1.0f;
+
+    int time = static_cast<int>(-1000 * velocity / acceleration);
+    if (time <= 0) return -1;
+
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Accel, time, velocity, acceleration, d->order++);
+    d->add(timeLineValue, op);
+
+    return time;
+}
+
+/*!
+    \overload
+
+    Decelerate \a timeLineValue from the starting \a velocity to zero at the
+    given \a acceleration rate over a maximum distance of maxDistance.
+
+    If necessary, StretchTimeLine will reduce the acceleration to ensure that the
+    entire operation does not require a move of more than \a maxDistance.
+    \a maxDistance should always be positive.
+*/
+int StretchTimeLine::accel(StretchTimeLineValue &timeLineValue, qreal velocity, qreal acceleration, qreal maxDistance)
+{
+    if (qFuzzyIsNull(maxDistance) || qt_is_nan(maxDistance) || qFuzzyIsNull(acceleration) || qt_is_nan(acceleration))
+        return -1;
+
+    Q_ASSERT(acceleration > 0.0f && maxDistance > 0.0f);
+
+    qreal maxAccel = (velocity * velocity) / (2.0f * maxDistance);
+    if (maxAccel > acceleration)
+        acceleration = maxAccel;
+
+    if ((velocity > 0.0f) == (acceleration > 0.0f))
+        acceleration = acceleration * -1.0f;
+
+    int time = static_cast<int>(-1000 * velocity / acceleration);
+    if (time <= 0) return -1;
+
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Accel, time, velocity, acceleration, d->order++);
+    d->add(timeLineValue, op);
+
+    return time;
+}
+
+/*!
+    Decelerate \a timeLineValue from the starting \a velocity to zero over the given
+    \a distance.  This is like accel(), but the StretchTimeLine calculates the exact
+    deceleration to use.
+
+    \a distance should be positive.
+*/
+int StretchTimeLine::accelDistance(StretchTimeLineValue &timeLineValue, qreal velocity, qreal distance)
+{
+    if (qFuzzyIsNull(distance) || qt_is_nan(distance) || qFuzzyIsNull(velocity) || qt_is_nan(velocity))
+        return -1;
+
+    Q_ASSERT((distance >= 0.0f) == (velocity >= 0.0f));
+
+    int time = static_cast<int>(1000 * (2.0f * distance) / velocity);
+    if (time <= 0) return -1;
+
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::AccelDistance, time, velocity, distance, d->order++);
+    d->add(timeLineValue, op);
+
+    return time;
+}
+
+/*!
+    Linearly change the \a timeLineValue from its current value to the given
+    \a destination value over \a time milliseconds.
+*/
+void StretchTimeLine::move(StretchTimeLineValue &timeLineValue, qreal destination, int time)
+{
+    if (time <= 0) return;
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Move, time, destination, 0.0f, d->order++);
+    d->add(timeLineValue, op);
+}
+
+/*!
+    Change the \a timeLineValue from its current value to the given \a destination
+    value over \a time milliseconds using the \a easing curve.
+ */
+void StretchTimeLine::move(StretchTimeLineValue &timeLineValue, qreal destination, const QEasingCurve &easing, int time)
+{
+    if (time <= 0) return;
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::Move, time, destination, 0.0f, d->order++, StretchTimeLineCallback(), easing);
+    d->add(timeLineValue, op);
+}
+
+/*!
+    Linearly change the \a timeLineValue from its current value by the \a change amount
+    over \a time milliseconds.
+*/
+void StretchTimeLine::moveBy(StretchTimeLineValue &timeLineValue, qreal change, int time)
+{
+    if (time <= 0) return;
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::MoveBy, time, change, 0.0f, d->order++);
+    d->add(timeLineValue, op);
+}
+
+/*!
+    Change the \a timeLineValue from its current value by the \a change amount over
+    \a time milliseconds using the \a easing curve.
+ */
+void StretchTimeLine::moveBy(StretchTimeLineValue &timeLineValue, qreal change, const QEasingCurve &easing, int time)
+{
+    if (time <= 0) return;
+    StretchTimeLinePrivate::Op op(StretchTimeLinePrivate::Op::MoveBy, time, change, 0.0f, d->order++, StretchTimeLineCallback(), easing);
+    d->add(timeLineValue, op);
+}
+
+/*!
+    Cancel (but don't complete) all scheduled actions for \a timeLineValue.
+*/
+void StretchTimeLine::reset(StretchTimeLineValue &timeLineValue)
+{
+    if (!timeLineValue._t)
+        return;
+    if (timeLineValue._t != this) {
+        qWarning() << "StretchTimeLine: Cannot reset a StretchTimeLineValue owned by another timeline.";
+        return;
+    }
+    qCDebug(lcTl) << static_cast<QObject*>(this) << timeLineValue.value();
+    remove(&timeLineValue);
+    timeLineValue._t = nullptr;
+}
+
+int StretchTimeLine::duration() const
+{
+    return -1;
+}
+
+/*!
+    Synchronize the end point of \a timeLineValue to the endpoint of \a syncTo
+    within this timeline.
+
+    Following operations on \a timeLineValue in this timeline will be scheduled after
+    all the currently scheduled actions on \a syncTo are complete.  In
+    pseudo-code this is equivalent to:
+    \code
+    StretchTimeLine::pause(timeLineValue, min(0, length_of(syncTo) - length_of(timeLineValue)))
+    \endcode
+*/
+void StretchTimeLine::sync(StretchTimeLineValue &timeLineValue, StretchTimeLineValue &syncTo)
+{
+    StretchTimeLinePrivate::Ops::Iterator iter = d->ops.find(&syncTo);
+    if (iter == d->ops.end())
+        return;
+    int length = iter->length;
+
+    iter = d->ops.find(&timeLineValue);
+    if (iter == d->ops.end()) {
+        pause(timeLineValue, length);
+    } else {
+        int glength = iter->length;
+        pause(timeLineValue, length - glength);
+    }
+}
+
+/*!
+    Synchronize the end point of \a timeLineValue to the endpoint of the longest
+    action cursrently scheduled in the timeline.
+
+    In pseudo-code, this is equivalent to:
+    \code
+    StretchTimeLine::pause(timeLineValue, length_of(timeline) - length_of(timeLineValue))
+    \endcode
+*/
+void StretchTimeLine::sync(StretchTimeLineValue &timeLineValue)
+{
+    StretchTimeLinePrivate::Ops::Iterator iter = d->ops.find(&timeLineValue);
+    if (iter == d->ops.end()) {
+        pause(timeLineValue, d->length);
+    } else {
+        pause(timeLineValue, d->length - iter->length);
+    }
+}
+
+/*
+    Synchronize all currently and future scheduled values in this timeline to
+    the longest action currently scheduled.
+
+    For example:
+    \code
+    value1->setValue(0.);
+    value2->setValue(0.);
+    value3->setValue(0.);
+    StretchTimeLine tl;
+    ...
+    tl.move(value1, 10, 200);
+    tl.move(value2, 10, 100);
+    tl.sync();
+    tl.move(value2, 20, 100);
+    tl.move(value3, 20, 100);
+    \endcode
+
+    will result in:
+
+    \table
+    \header \li \li 0ms \li 50ms \li 100ms \li 150ms \li 200ms \li 250ms \li 300ms
+    \row \li value1 \li 0 \li 2.5 \li 5.0 \li 7.5 \li 10 \li 10 \li 10
+    \row \li value2 \li 0 \li 5.0 \li 10.0 \li 10.0 \li 10.0 \li 15.0 \li 20.0
+    \row \li value2 \li 0 \li 0 \li 0 \li 0 \li 0 \li 10.0 \li 20.0
+    \endtable
+*/
+
+/*void StretchTimeLine::sync()
+{
+    for (StretchTimeLinePrivate::Ops::Iterator iter = d->ops.begin();
+            iter != d->ops.end();
+            ++iter)
+        pause(*iter.key(), d->length - iter->length);
+    d->syncPoint = d->length;
+}*/
+
+/*!
+    \internal
+
+    Temporary hack.
+ */
+void StretchTimeLine::setSyncPoint(int sp)
+{
+    d->syncPoint = sp;
+}
+
+/*!
+    \internal
+
+    Temporary hack.
+ */
+int StretchTimeLine::syncPoint() const
+{
+    return d->syncPoint;
+}
+
+/*!
+    Returns true if the timeline is active.  An active timeline is one where
+    StretchTimeLineValue actions are still pending.
+*/
+bool StretchTimeLine::isActive() const
+{
+    return !d->ops.isEmpty();
+}
+
+/*!
+    Completes the timeline.  All queued actions are played to completion, and then discarded.  For example,
+    \code
+    StretchTimeLineValue v(0.);
+    StretchTimeLine tl;
+    tl.move(v, 100., 1000.);
+    // 500 ms passes
+    // v.value() == 50.
+    tl.complete();
+    // v.value() == 100.
+    \endcode
+*/
+void StretchTimeLine::complete()
+{
+    d->advance(d->length);
+}
+
+/*!
+    Resets the timeline.  All queued actions are discarded and StretchTimeLineValue's retain their current value. For example,
+    \code
+    StretchTimeLineValue v(0.);
+    StretchTimeLine tl;
+    tl.move(v, 100., 1000.);
+    // 500 ms passes
+    // v.value() == 50.
+    tl.clear();
+    // v.value() == 50.
+    \endcode
+*/
+void StretchTimeLine::clear()
+{
+    for (StretchTimeLinePrivate::Ops::const_iterator iter = d->ops.cbegin(), cend  = d->ops.cend(); iter != cend; ++iter)
+        iter.key()->_t = nullptr;
+    d->ops.clear();
+    d->length = 0;
+    d->syncPoint = 0;
+    //XXX need stop here?
+}
+
+int StretchTimeLine::time() const
+{
+    return d->prevTime;
+}
+
+/*!
+    \fn void StretchTimeLine::updated()
+
+    Emitted each time the timeline modifies StretchTimeLineValues.  Even if multiple
+    StretchTimeLineValues are changed, this signal is only emitted once for each clock tick.
+*/
+
+void StretchTimeLine::updateCurrentTime(int v)
+{
+    if (d->syncAdj == -1)
+        d->syncAdj = v;
+    v -= d->syncAdj;
+
+    int timeChanged = v - d->prevTime;
+#if 0
+    if (!timeChanged)
+        return;
+#endif
+    d->prevTime = v;
+    d->advance(timeChanged);
+    emit updated();
+
+    // Do we need to stop the clock?
+    if (d->ops.isEmpty()) {
+        stop();
+        d->prevTime = 0;
+        d->clockRunning = false;
+        emit completed();
+    } /*else if (pauseTime > 0) {
+        GfxClock::cancelClock();
+        d->prevTime = 0;
+        GfxClock::pauseFor(pauseTime);
+        d->syncAdj = 0;
+        d->clockRunning = false;
+    }*/ else if (/*!GfxClock::isActive()*/ state() != Running) {
+        stop();
+        d->prevTime = 0;
+        d->clockRunning = true;
+        d->syncAdj = 0;
+        start();
+    }
+}
+
+void StretchTimeLine::debugAnimation(QDebug d) const
+{
+    d << "QuickTimeLine(" << Qt::hex << (const void *) this << Qt::dec << ")";
+}
+
+bool operator<(const QPair<int, Update> &lhs,
+               const QPair<int, Update> &rhs)
+{
+    return lhs.first < rhs.first;
+}
+
+int StretchTimeLinePrivate::advance(int t)
+{
+    int pauseTime = -1;
+
+    // XXX - surely there is a more efficient way?
+    do {
+        pauseTime = -1;
+        // Minimal advance time
+        int advanceTime = t;
+        for (Ops::const_iterator iter = ops.constBegin(), cend = ops.constEnd(); iter != cend; ++iter) {
+            const TimeLine &tl = *iter;
+            const Op &op = tl.ops.first();
+            int length = op.length - tl.consumedOpLength;
+
+            if (length < advanceTime) {
+                advanceTime = length;
+                if (advanceTime == 0)
+                    break;
+            }
+        }
+        t -= advanceTime;
+
+        // Process until then.  A zero length advance time will only process
+        // sets.
+        QList<QPair<int, Update> > updates;
+
+        for (Ops::Iterator iter = ops.begin(); iter != ops.end(); ) {
+            StretchTimeLineValue *v = static_cast<StretchTimeLineValue *>(iter.key());
+            TimeLine &tl = *iter;
+            Q_ASSERT(!tl.ops.isEmpty());
+
+            do {
+                Op &op = tl.ops.first();
+                if (advanceTime == 0 && op.length != 0)
+                    continue;
+
+                if (tl.consumedOpLength == 0 &&
+                   op.type != Op::Pause &&
+                   op.type != Op::Execute)
+                    tl.base = v->value();
+
+                if ((tl.consumedOpLength + advanceTime) == op.length) {
+                    // Finishing operation, the timeline value will be the operation's target value.
+                    if (op.type == Op::Execute) {
+                        updates << qMakePair(op.order, Update(op.event));
+                    } else {
+                        bool changed = false;
+                        qreal val = value(op, op.length, tl.base, &changed);
+                        if (changed)
+                            updates << qMakePair(op.order, Update(v, val));
+                    }
+                    tl.length -= qMin(advanceTime, tl.length);
+                    tl.consumedOpLength = 0;
+                    tl.ops.removeFirst();
+                } else {
+                    // Partially finished operation, the timeline value will be between the base
+                    // value and the target value, depending on progress and type of operation.
+                    tl.consumedOpLength += advanceTime;
+                    bool changed = false;
+                    qreal val = value(op, tl.consumedOpLength, tl.base, &changed);
+                    if (changed)
+                        updates << qMakePair(op.order, Update(v, val));
+                    tl.length -= qMin(advanceTime, tl.length);
+                    break;
+                }
+
+            } while(!tl.ops.isEmpty() && advanceTime == 0 && tl.ops.first().length == 0);
+
+
+            if (tl.ops.isEmpty()) {
+                iter = ops.erase(iter);
+                v->_t = nullptr;
+            } else {
+                if (tl.ops.first().type == Op::Pause && pauseTime != 0) {
+                    int opPauseTime = tl.ops.first().length - tl.consumedOpLength;
+                    if (pauseTime == -1 || opPauseTime < pauseTime)
+                        pauseTime = opPauseTime;
+                } else {
+                    pauseTime = 0;
+                }
+                ++iter;
+            }
+        }
+
+        length -= qMin(length, advanceTime);
+        syncPoint -= advanceTime;
+
+        std::sort(updates.begin(), updates.end());
+        updateQueue = &updates;
+        for (int ii = 0; ii < updates.size(); ++ii) {
+            const Update &v = updates.at(ii).second;
+            if (v.g) {
+                v.g->setValue(v.v);
+            } else {
+                v.e.d0(v.e.d1);
+            }
+        }
+        updateQueue = nullptr;
+    } while(t);
+
+    return pauseTime;
+}
+
+void StretchTimeLine::remove(StretchTimeLineObject *v)
+{
+    StretchTimeLinePrivate::Ops::Iterator iter = d->ops.find(v);
+    Q_ASSERT(iter != d->ops.end());
+
+    int len = iter->length;
+    d->ops.erase(iter);
+    if (len == d->length) {
+        // We need to recalculate the length
+        d->length = 0;
+        for (StretchTimeLinePrivate::Ops::Iterator iter = d->ops.begin();
+                iter != d->ops.end();
+                ++iter) {
+
+            if (iter->length > d->length)
+                d->length = iter->length;
+
+        }
+    }
+    if (d->ops.isEmpty()) {
+        stop();
+        d->clockRunning = false;
+    } else if (state() != Running) { // was !GfxClock::isActive()
+        stop();
+        d->prevTime = 0;
+        d->clockRunning = true;
+
+        if (d->syncMode == StretchTimeLine::LocalSync) {
+            d->syncAdj = -1;
+        } else {
+            d->syncAdj = 0;
+        }
+        start();
+    }
+
+    if (d->updateQueue) {
+        for (int ii = 0; ii < d->updateQueue->size(); ++ii) {
+            if (d->updateQueue->at(ii).second.g == v ||
+               d->updateQueue->at(ii).second.e.callbackObject() == v) {
+                d->updateQueue->removeAt(ii);
+                --ii;
+            }
+        }
+    }
+
+
+}
+
+/*!
+    \internal
+    \class StretchTimeLineValue
+    \brief The StretchTimeLineValue class provides a value that can be modified by StretchTimeLine.
+*/
+
+/*!
+    \fn StretchTimeLineValue::StretchTimeLineValue(qreal value = 0)
+
+    Construct a new StretchTimeLineValue with an initial \a value.
+*/
+
+/*!
+    \fn qreal StretchTimeLineValue::value() const
+
+    Return the current value.
+*/
+
+/*!
+    \fn void StretchTimeLineValue::setValue(qreal value)
+
+    Set the current \a value.
+*/
+
+/*!
+    \fn StretchTimeLine *StretchTimeLineValue::timeLine() const
+
+    If a StretchTimeLine is operating on this value, return a pointer to it,
+    otherwise return null.
+*/
+
+
+StretchTimeLineObject::StretchTimeLineObject()
+: _t(nullptr)
+{
+}
+
+StretchTimeLineObject::~StretchTimeLineObject()
+{
+    if (_t) {
+        _t->remove(this);
+        _t = nullptr;
+    }
+}
+
+StretchTimeLineCallback::StretchTimeLineCallback()
+: d0(nullptr), d1(nullptr), d2(nullptr)
+{
+}
+
+StretchTimeLineCallback::StretchTimeLineCallback(StretchTimeLineObject *b, Callback f, void *d)
+: d0(f), d1(d), d2(b)
+{
+}
+
+StretchTimeLineCallback::StretchTimeLineCallback(const StretchTimeLineCallback &o)
+: d0(o.d0), d1(o.d1), d2(o.d2)
+{
+}
+
+StretchTimeLineCallback &StretchTimeLineCallback::operator=(const StretchTimeLineCallback &o)
+{
+    d0 = o.d0;
+    d1 = o.d1;
+    d2 = o.d2;
+    return *this;
+}
+
+StretchTimeLineObject *StretchTimeLineCallback::callbackObject() const
+{
+    return d2;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_stretchtimeline_p_p.cpp"
diff --git a/src/stretchtimeline_p_p.h b/src/stretchtimeline_p_p.h
new file mode 100644
index 0000000..9360c7f
--- /dev/null
+++ b/src/stretchtimeline_p_p.h
@@ -0,0 +1,156 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef STRETCHTIMELINE_H
+#define STRETCHTIMELINE_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/QObject>
+#include <private/qtquickglobal_p.h>
+#include "private/qabstractanimationjob_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEasingCurve;
+class StretchTimeLineValue;
+class StretchTimeLineCallback;
+struct StretchTimeLinePrivate;
+class StretchTimeLineObject;
+class StretchTimeLine : public QObject, QAbstractAnimationJob
+{
+Q_OBJECT
+public:
+    StretchTimeLine(QObject *parent = nullptr);
+    ~StretchTimeLine();
+
+    enum SyncMode { LocalSync, GlobalSync };
+    SyncMode syncMode() const;
+    void setSyncMode(SyncMode);
+
+    void pause(StretchTimeLineObject &, int);
+    void callback(const StretchTimeLineCallback &);
+    void set(StretchTimeLineValue &, qreal);
+
+    int accel(StretchTimeLineValue &, qreal velocity, qreal accel);
+    int accel(StretchTimeLineValue &, qreal velocity, qreal accel, qreal maxDistance);
+    int accelDistance(StretchTimeLineValue &, qreal velocity, qreal distance);
+
+    void move(StretchTimeLineValue &, qreal destination, int time = 500);
+    void move(StretchTimeLineValue &, qreal destination, const QEasingCurve &, int time = 500);
+    void moveBy(StretchTimeLineValue &, qreal change, int time = 500);
+    void moveBy(StretchTimeLineValue &, qreal change, const QEasingCurve &, int time = 500);
+
+    void sync();
+    void setSyncPoint(int);
+    int syncPoint() const;
+
+    void sync(StretchTimeLineValue &);
+    void sync(StretchTimeLineValue &, StretchTimeLineValue &);
+
+    void reset(StretchTimeLineValue &);
+
+    void complete();
+    void clear();
+    bool isActive() const;
+
+    int time() const;
+
+    int duration() const override;
+Q_SIGNALS:
+    void updated();
+    void completed();
+
+protected:
+    void updateCurrentTime(int) override;
+    void debugAnimation(QDebug d) const override;
+
+private:
+    void remove(StretchTimeLineObject *);
+    friend class StretchTimeLineObject;
+    friend struct StretchTimeLinePrivate;
+    StretchTimeLinePrivate *d;
+};
+
+class  StretchTimeLineObject
+{
+public:
+    StretchTimeLineObject();
+    virtual ~StretchTimeLineObject();
+
+protected:
+    friend class StretchTimeLine;
+    friend struct StretchTimeLinePrivate;
+    StretchTimeLine *_t;
+};
+
+class  StretchTimeLineValue : public StretchTimeLineObject
+{
+public:
+    StretchTimeLineValue(qreal v = 0.) : _v(v) {}
+
+    virtual qreal value() const { return _v; }
+    virtual void setValue(qreal v) { _v = v; }
+
+    StretchTimeLine *timeLine() const { return _t; }
+
+    operator qreal() const { return _v; }
+    StretchTimeLineValue &operator=(qreal v) { setValue(v); return *this; }
+private:
+    friend class StretchTimeLine;
+    friend struct StretchTimeLinePrivate;
+    qreal _v;
+};
+
+class  StretchTimeLineCallback
+{
+public:
+    typedef void (*Callback)(void *);
+
+    StretchTimeLineCallback();
+    StretchTimeLineCallback(StretchTimeLineObject *b, Callback, void * = nullptr);
+    StretchTimeLineCallback(const StretchTimeLineCallback &o);
+
+    StretchTimeLineCallback &operator=(const StretchTimeLineCallback &o);
+    StretchTimeLineObject *callbackObject() const;
+
+private:
+    friend struct StretchTimeLinePrivate;
+    Callback d0;
+    void *d1;
+    StretchTimeLineObject *d2;
+};
+
+template<class T>
+class StretchTimeLineValueProxy : public StretchTimeLineValue
+{
+public:
+    StretchTimeLineValueProxy(T *object, void (T::*func)(qreal), qreal v = 0.)
+    : StretchTimeLineValue(v), object(object), setter(func)
+    {
+        Q_ASSERT(object);
+    }
+
+    void setValue(qreal v) override
+    {
+        StretchTimeLineValue::setValue(v);
+        (object->*setter)(v);
+    }
+
+private:
+    T *object;
+    void (T::*setter)(qreal);
+};
+
+QT_END_NAMESPACE
+
+#endif

src / ferdios / libqml6stretch

Initial commit