add noctalia and fuzzel

2026-05-23 21:20:58 +02:00
parent 364801f1a3
commit 9a3eceb3ab
599 changed files with 204318 additions and 0 deletions
@@ -0,0 +1,430 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Templates as T
+import qs.Commons
+
+Item {
+  id: root
+
+  // Signal for key press events when keyNavigationEnabled is true
+  signal keyPressed(var event)
+
+  property color handleColor: Qt.alpha(Color.mHover, 0.8)
+  property color handleHoverColor: handleColor
+  property color handlePressedColor: handleColor
+  property color trackColor: "transparent"
+  property real handleWidth: 6
+  property real handleRadius: Style.iRadiusM
+  property int verticalPolicy: ScrollBar.AsNeeded
+  property int horizontalPolicy: ScrollBar.AlwaysOff
+  readonly property bool verticalScrollBarActive: {
+    if (gridView.ScrollBar.vertical.policy === ScrollBar.AlwaysOff)
+      return false;
+    return gridView.contentHeight > gridView.height;
+  }
+  readonly property bool contentOverflows: gridView.contentHeight > gridView.height
+
+  // Gradient properties
+  property bool showGradientMasks: true
+  property color gradientColor: Color.mSurfaceVariant
+  property int gradientHeight: 16
+  property bool reserveScrollbarSpace: true
+
+  // Keep scrollbars visible whenever overflow exists (without forcing visibility when not scrollable)
+  property bool showScrollbarWhenScrollable: Settings.data.ui.scrollbarAlwaysVisible
+
+  // Available width for content (excludes scrollbar space when reserveScrollbarSpace is true)
+  // Note: Always reserves space when enabled to avoid binding loops with cellWidth calculations
+  readonly property real availableWidth: width - (reserveScrollbarSpace ? handleWidth + Style.marginXS : 0)
+
+  // Expose activeFocus from internal gridView
+  readonly property bool hasActiveFocus: gridView.activeFocus
+
+  // Forward GridView properties
+  property alias model: gridView.model
+  property alias delegate: gridView.delegate
+  property alias cellWidth: gridView.cellWidth
+  property alias cellHeight: gridView.cellHeight
+  property alias leftMargin: gridView.leftMargin
+  property alias rightMargin: gridView.rightMargin
+  property alias topMargin: gridView.topMargin
+  property alias bottomMargin: gridView.bottomMargin
+  property alias currentIndex: gridView.currentIndex
+  property alias count: gridView.count
+  property alias contentHeight: gridView.contentHeight
+  property alias contentWidth: gridView.contentWidth
+  property alias contentY: gridView.contentY
+  property alias contentX: gridView.contentX
+  property alias currentItem: gridView.currentItem
+  property alias highlightItem: gridView.highlightItem
+  property alias highlightFollowsCurrentItem: gridView.highlightFollowsCurrentItem
+  property alias preferredHighlightBegin: gridView.preferredHighlightBegin
+  property alias preferredHighlightEnd: gridView.preferredHighlightEnd
+  property alias highlightRangeMode: gridView.highlightRangeMode
+  property alias snapMode: gridView.snapMode
+  property alias keyNavigationEnabled: gridView.keyNavigationEnabled
+  property alias keyNavigationWraps: gridView.keyNavigationWraps
+  property alias cacheBuffer: gridView.cacheBuffer
+  property alias displayMarginBeginning: gridView.displayMarginBeginning
+  property alias displayMarginEnd: gridView.displayMarginEnd
+  property alias layoutDirection: gridView.layoutDirection
+  property alias effectiveLayoutDirection: gridView.effectiveLayoutDirection
+  property alias flow: gridView.flow
+  property alias boundsBehavior: gridView.boundsBehavior
+  property alias flickableDirection: gridView.flickableDirection
+  property alias interactive: gridView.interactive
+  property alias moving: gridView.moving
+  property alias flicking: gridView.flicking
+  property alias dragging: gridView.dragging
+  property alias horizontalVelocity: gridView.horizontalVelocity
+  property alias verticalVelocity: gridView.verticalVelocity
+  property alias reuseItems: gridView.reuseItems
+
+  // Animate items when the model is reordered (e.g. ListModel.move())
+  property bool animateMovement: false
+
+  // Scroll speed multiplier for mouse wheel (1.0 = default, higher = faster)
+  property real wheelScrollMultiplier: 2.0
+  property int smoothWheelAnimationDuration: Style.animationNormal
+  property real _wheelTargetY: 0
+
+  function clampScrollY(value) {
+    return Math.max(0, Math.min(value, gridView.contentHeight - gridView.height));
+  }
+
+  function applyWheelScroll(delta) {
+    if (!root.contentOverflows)
+      return;
+
+    const step = delta * root.wheelScrollMultiplier;
+
+    if (!Settings.data.general.smoothScrollEnabled || Settings.data.general.animationDisabled) {
+      gridView.contentY = root.clampScrollY(gridView.contentY - step);
+      root._wheelTargetY = gridView.contentY;
+      return;
+    }
+
+    if (!wheelScrollAnimation.running)
+      root._wheelTargetY = gridView.contentY;
+
+    root._wheelTargetY = root.clampScrollY(root._wheelTargetY - step);
+    wheelScrollAnimation.to = root._wheelTargetY;
+    wheelScrollAnimation.restart();
+  }
+
+  function animateToContentY(targetY) {
+    const clampedY = root.clampScrollY(targetY);
+
+    if (!Settings.data.general.smoothScrollEnabled || Settings.data.general.animationDisabled || gridView.dragging || gridView.flicking) {
+      gridView.contentY = clampedY;
+      root._wheelTargetY = clampedY;
+      return;
+    }
+
+    root._wheelTargetY = clampedY;
+    wheelScrollAnimation.to = clampedY;
+    wheelScrollAnimation.restart();
+  }
+
+  // Track selection index for gradient visibility (set externally)
+  property int trackedSelectionIndex: -1
+
+  // Check if selection is on first visible row
+  readonly property bool selectionOnFirstVisibleRow: {
+    if (trackedSelectionIndex < 0 || cellHeight <= 0 || cellWidth <= 0)
+      return false;
+
+    // Calculate columns per row
+    var cols = Math.floor(gridView.width / cellWidth);
+    if (cols <= 0)
+      cols = 1;
+
+    // Calculate the row of the selection
+    var selectionRow = Math.round(trackedSelectionIndex / cols);
+
+    // Calculate the first visible row
+    var firstVisibleRow = Math.round(gridView.contentY / cellHeight);
+
+    return selectionRow === firstVisibleRow;
+  }
+
+  // Check if selection is on last visible row
+  readonly property bool selectionOnLastVisibleRow: {
+    if (trackedSelectionIndex < 0 || cellHeight <= 0 || cellWidth <= 0)
+      return false;
+
+    // Calculate columns per row
+    var cols = Math.floor(gridView.width / cellWidth);
+    if (cols <= 0)
+      cols = 1;
+
+    // Calculate the row of the selection
+    var selectionRow = Math.round(trackedSelectionIndex / cols);
+
+    // Calculate the last visible row (might be partially visible)
+    var lastVisibleRow = Math.round((gridView.contentY + gridView.height - 1) / cellHeight);
+
+    return selectionRow === lastVisibleRow;
+  }
+
+  // Forward GridView methods
+  function positionViewAtIndex(index, mode) {
+    const shouldAnimate = mode === GridView.Contain;
+    if (!shouldAnimate) {
+      gridView.positionViewAtIndex(index, mode);
+      root._wheelTargetY = gridView.contentY;
+      return;
+    }
+
+    const previousY = gridView.contentY;
+    gridView.positionViewAtIndex(index, mode);
+    const targetY = root.clampScrollY(gridView.contentY);
+
+    if (Math.abs(targetY - previousY) < 0.5) {
+      root._wheelTargetY = targetY;
+      return;
+    }
+
+    gridView.contentY = previousY;
+    root._wheelTargetY = previousY;
+    root.animateToContentY(targetY);
+  }
+
+  function positionViewAtBeginning() {
+    gridView.positionViewAtBeginning();
+  }
+
+  function positionViewAtEnd() {
+    gridView.positionViewAtEnd();
+  }
+
+  function forceLayout() {
+    gridView.forceLayout();
+  }
+
+  function forceActiveFocus() {
+    gridView.forceActiveFocus();
+  }
+
+  function cancelFlick() {
+    gridView.cancelFlick();
+  }
+
+  function flick(xVelocity, yVelocity) {
+    gridView.flick(xVelocity, yVelocity);
+  }
+
+  function incrementCurrentIndex() {
+    gridView.incrementCurrentIndex();
+  }
+
+  function decrementCurrentIndex() {
+    gridView.decrementCurrentIndex();
+  }
+
+  function indexAt(x, y) {
+    return gridView.indexAt(x, y);
+  }
+
+  function itemAt(x, y) {
+    return gridView.itemAt(x, y);
+  }
+
+  function itemAtIndex(index) {
+    return gridView.itemAtIndex(index);
+  }
+
+  function moveCurrentIndexUp() {
+    gridView.moveCurrentIndexUp();
+  }
+
+  function moveCurrentIndexDown() {
+    gridView.moveCurrentIndexDown();
+  }
+
+  function moveCurrentIndexLeft() {
+    gridView.moveCurrentIndexLeft();
+  }
+
+  function moveCurrentIndexRight() {
+    gridView.moveCurrentIndexRight();
+  }
+
+  // Set reasonable implicit sizes for Layout usage
+  implicitWidth: 200
+  implicitHeight: 200
+
+  Component.onCompleted: {
+    _wheelTargetY = gridView.contentY;
+    createGradients();
+  }
+
+  // Dynamically create gradient overlays
+  function createGradients() {
+    if (!showGradientMasks)
+      return;
+
+    Qt.createQmlObject(`
+      import QtQuick
+      import qs.Commons
+      Rectangle {
+        x: 0
+        y: 0
+        width: root.availableWidth
+        height: root.gradientHeight
+        z: 1
+        visible: root.showGradientMasks && root.contentOverflows
+        opacity: (gridView.contentY <= 1 || root.selectionOnFirstVisibleRow) ? 0 : 1
+        Behavior on opacity {
+          NumberAnimation { duration: Style.animationFast; easing.type: Easing.InOutQuad }
+        }
+        gradient: Gradient {
+          GradientStop { position: 0.0; color: root.gradientColor }
+          GradientStop { position: 1.0; color: "transparent" }
+        }
+      }
+    `, root, "topGradient");
+
+    Qt.createQmlObject(`
+      import QtQuick
+      import qs.Commons
+      Rectangle {
+        x: 0
+        anchors.bottom: parent.bottom
+        anchors.bottomMargin: -1
+        width: root.availableWidth
+        height: root.gradientHeight + 1
+        z: 1
+        visible: root.showGradientMasks && root.contentOverflows
+        opacity: ((gridView.contentY + gridView.height >= gridView.contentHeight - 1) || root.selectionOnLastVisibleRow) ? 0 : 1
+        Behavior on opacity {
+          NumberAnimation { duration: Style.animationFast; easing.type: Easing.InOutQuad }
+        }
+        gradient: Gradient {
+          GradientStop { position: 0.0; color: "transparent" }
+          GradientStop { position: 1.0; color: root.gradientColor }
+        }
+      }
+    `, root, "bottomGradient");
+  }
+
+  GridView {
+    id: gridView
+    anchors.fill: parent
+    anchors.rightMargin: root.reserveScrollbarSpace ? root.handleWidth + Style.marginXS : 0
+
+    move: root.animateMovement ? moveTransitionImpl : null
+    displaced: root.animateMovement ? displacedTransitionImpl : null
+
+    Transition {
+      id: moveTransitionImpl
+      NumberAnimation {
+        properties: "x,y"
+        duration: Style.animationNormal
+        easing.type: Easing.InOutQuad
+      }
+    }
+    Transition {
+      id: displacedTransitionImpl
+      NumberAnimation {
+        properties: "x,y"
+        duration: Style.animationNormal
+        easing.type: Easing.InOutQuad
+      }
+    }
+
+    // Enable clipping to keep content within bounds
+    clip: true
+
+    // Enable flickable for smooth scrolling
+    boundsBehavior: Flickable.StopAtBounds
+
+    NumberAnimation {
+      id: wheelScrollAnimation
+      target: gridView
+      property: "contentY"
+      duration: root.smoothWheelAnimationDuration
+      easing.type: Easing.OutCubic
+    }
+
+    onDraggingChanged: {
+      if (dragging) {
+        wheelScrollAnimation.stop();
+        root._wheelTargetY = contentY;
+      }
+    }
+
+    onFlickingChanged: {
+      if (flicking) {
+        wheelScrollAnimation.stop();
+        root._wheelTargetY = contentY;
+      }
+    }
+
+    onContentHeightChanged: root._wheelTargetY = root.clampScrollY(root._wheelTargetY)
+    onHeightChanged: root._wheelTargetY = root.clampScrollY(root._wheelTargetY)
+
+    // Focus handling depends on keyNavigationEnabled
+    focus: keyNavigationEnabled
+    activeFocusOnTab: keyNavigationEnabled
+
+    // Emit keyPressed signal for custom key handling
+    Keys.onPressed: event => {
+                      if (keyNavigationEnabled) {
+                        root.keyPressed(event);
+                      }
+                    }
+
+    WheelHandler {
+      enabled: root.wheelScrollMultiplier !== 1.0
+      acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad
+      onWheel: event => {
+                 const delta = event.pixelDelta.y !== 0 ? event.pixelDelta.y : event.angleDelta.y / 2;
+                 root.applyWheelScroll(delta);
+                 event.accepted = true;
+               }
+    }
+
+    ScrollBar.vertical: ScrollBar {
+      parent: root
+      x: root.mirrored ? 0 : root.width - width
+      y: 0
+      height: root.height
+      policy: root.verticalPolicy
+
+      contentItem: Rectangle {
+        implicitWidth: root.handleWidth
+        implicitHeight: 100
+        radius: root.handleRadius
+        color: parent.pressed ? root.handlePressedColor : parent.hovered ? root.handleHoverColor : root.handleColor
+        opacity: parent.policy === ScrollBar.AlwaysOn ? 1.0 : root.verticalScrollBarActive ? ((root.showScrollbarWhenScrollable || parent.active) ? 1.0 : 0.0) : 0.0
+
+        Behavior on opacity {
+          NumberAnimation {
+            duration: Style.animationFast
+          }
+        }
+
+        Behavior on color {
+          ColorAnimation {
+            duration: Style.animationFast
+          }
+        }
+      }
+
+      background: Rectangle {
+        implicitWidth: root.handleWidth
+        implicitHeight: 100
+        color: root.trackColor
+        opacity: parent.policy === ScrollBar.AlwaysOn ? 0.3 : root.verticalScrollBarActive ? ((root.showScrollbarWhenScrollable || parent.active) ? 0.3 : 0.0) : 0.0
+        radius: root.handleRadius / 2
+
+        Behavior on opacity {
+          NumberAnimation {
+            duration: Style.animationFast
+          }
+        }
+      }
+    }
+  }
+}