Warning, /frameworks/kirigami/src/controls/private/PullDownIndicator.qml is written in an unsupported language. File is not indexed.

 /*
  *  SPDX-FileCopyrightText: 2023 Connor Carney <hello@connorcarney.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 import QtQuick
 import QtQuick.Controls as QQC2
 import org.kde.kirigami as Kirigami
 import QtQuick.Shapes as QQShapes
 
 /**
  * @brief A pull-down to refresh indicator that can be added to any Flickable or ScrollablePage.
  */
 Item {
     id: root
 
     //BEGIN properties
     /**
      * @brief The flickable that this indicator is attached to.
      *
      * If this is not set, the indicator will search for a Flickable in its parent chain.
      */
     property Flickable flickable: {
         let candidate = parent
         while (candidate) {
             if (candidate instanceof Flickable) {
                 return candidate
             } else if (candidate instanceof Kirigami.ScrollablePage) {
                 return candidate.flickable
             }
             candidate = candidate.parent
         }
         return null;
     }
 
     /**
      * @brief Whether to show the busy indicator at the top of the flickable
      *
      * This should be set to true whenever a refresh is in progress. It should typically
      * be set to true whe triggered() is emitted, and set to false when the refresh is
      * complete. This is not done automatically because the refresh may be triggered
      * from outside the indicator.
      */
     property bool active: false
 
     /**
      * @brief How far the flickable has been pulled down, between 0 (not at all) and 1 (where a refresh is triggered).
      */
     readonly property real progress: !refreshing ? Math.min(-Math.min(flickable?.verticalOvershoot ?? 0, 0) / indicatorContainer.height, 1) : 0
 
     /**
      * @brief Time to wait after the flickable has been pulled down before triggering a refresh
      *
      * This gives the user a chance to back out of the refresh if they release the flickable
      * before the refreshDelay has elapsed.
      */
     property int refreshDelay: 500
 
     /**
      * @brief emitted when the flickable is pulled down far enough to trigger a refresh
      */
     signal triggered()
     //END properties
 
     Item {
         id: indicatorContainer
         parent: root.flickable
         anchors {
             bottom: parent?.contentItem?.top
             bottomMargin: root.flickable.topMargin
         }
 
         width: flickable?.width
         height: Kirigami.Units.gridUnit * 4
         QQC2.BusyIndicator {
             id: busyIndicator
             z: 1
             anchors.centerIn: parent
             running: root.active
             visible: root.active
             // Android busywidget QQC seems to be broken at custom sizes
         }
         QQShapes.Shape {
             id: spinnerProgress
             anchors {
                 fill: busyIndicator
                 margins: Kirigami.Units.smallSpacing
             }
             visible: !root.active && root.progress > 0
             QQShapes.ShapePath {
                 strokeWidth: Kirigami.Units.smallSpacing
                 strokeColor: Kirigami.Theme.highlightColor
                 fillColor: "transparent"
                 PathAngleArc {
                     centerX: spinnerProgress.width / 2
                     centerY: spinnerProgress.height / 2
                     radiusX: spinnerProgress.width / 2 - Kirigami.Units.smallSpacing / 2
                     radiusY: spinnerProgress.height / 2 - Kirigami.Units.smallSpacing / 2
                     startAngle: 0
                     sweepAngle: 360 * root.progress
                 }
             }
         }
     }
 
     onProgressChanged: {
         if (!root.active && root.progress >= 1) {
             refreshTriggerTimer.running = true;
         } else {
             refreshTriggerTimer.running = false;
         }
     }
 
 
     states: [
         State {
             name: "active"
             when: root.active
             PropertyChanges {
                 target: indicatorContainer
                 anchors.bottomMargin: root.flickable.topMargin - indicatorContainer.height
             }
             PropertyChanges {
                 target: root.flickable
                 explicit: true
 
                 // this is not a loop because of explicit:true above
                 // It adds the height of the indicator to the topMargin of the flickable
                 // when we enter the active state; the change is automatically reversed
                 // when returning to the base state.
                 topMargin: indicatorContainer.height + root.flickable.topMargin
             }
         }
     ]
 
     transitions: [
         Transition {
             from: ""
             to: "active"
             enabled: root.flickable.verticalOvershoot >= 0
             reversible: true
             NumberAnimation {
                 target: root.flickable
                 properties: "topMargin"
                 easing.type: Easing.InOutQuad
                 duration: Kirigami.Units.longDuration
             }
         }
     ]
 
     Timer {
         id: refreshTriggerTimer
         interval: root.refreshDelay
         onTriggered: {
             if (!root.active && root.progress >= 1) {
                 root.triggered()
             }
         }
     }
 
 }