noctalia-shell/Modules/DesktopWidgets/DraggableDesktopWidget.qml

import QtQuick
import QtQuick.Effects
import Quickshell
import qs.Commons

Item {
  id: root

  // Required properties from parent (set by DesktopWidgets.qml loader)
  property ShellScreen screen
  property var widgetData: null
  property int widgetIndex: -1

  // Optional customization
  property real defaultX: 100
  property real defaultY: 100
  property color textColor: Color.mOnSurface

  // Content slot - allows natural QML child syntax
  default property alias content: contentContainer.data

  // Exposed state for child content (e.g., to disable shadow during drag)
  readonly property bool isDragging: internal.isDragging
  readonly property bool isScaling: internal.isScaling

  // Whether to show the background container
  property bool showBackground: (widgetData && widgetData.showBackground !== undefined) ? widgetData.showBackground : true

  // Widget size properties
  property real widgetScale: (widgetData && widgetData.scale !== undefined) ? widgetData.scale : 1.0
  property real minScale: 0.5
  property real maxScale: 3.0

  // Scaling sensitivity and threshold constants
  readonly property real scaleSensitivity: 0.0015  // Sensitivity for scaling (scale change per pixel of movement)
  readonly property real scaleUpdateThreshold: 0.015  // Minimum change required to update scale value

  // Internal dragging and scaling state
  QtObject {
    id: internal
    property bool isDragging: false
    property bool isScaling: false
    property real dragOffsetX: 0
    property real dragOffsetY: 0
    property real baseX: (root.widgetData && root.widgetData.x !== undefined) ? root.widgetData.x : root.defaultX
    property real baseY: (root.widgetData && root.widgetData.y !== undefined) ? root.widgetData.y : root.defaultY
    property real initialWidth: 0
    property real initialHeight: 0
    property point initialMousePos: Qt.point(0, 0)
    property real initialScale: 1.0
    property real lastScale: 1.0  // Track the last applied scale during scaling operation

    // Global state to manage scaling vs dragging exclusivity
    // When any operation starts (drag or scale), lock the type until operation completes
    property string operationType: ""  // "drag" or "scale" or ""
  }

  // Helper function to update widget data in settings
  function updateWidgetData(properties) {
    if (widgetIndex < 0 || !screen || !screen.name) {
      return; // Early return if necessary data is missing
    }

    var monitorWidgets = Settings.data.desktopWidgets.monitorWidgets || [];
    var newMonitorWidgets = monitorWidgets.slice();

    for (var i = 0; i < newMonitorWidgets.length; i++) {
      if (newMonitorWidgets[i].name === screen.name) {
        var widgets = (newMonitorWidgets[i].widgets || []).slice();
        if (widgetIndex < widgets.length) {
          widgets[widgetIndex] = Object.assign({}, widgets[widgetIndex], properties);
          newMonitorWidgets[i] = Object.assign({}, newMonitorWidgets[i], {
            "widgets": widgets
          });
          Settings.data.desktopWidgets.monitorWidgets = newMonitorWidgets;
        }
        break;
      }
    }
  }

  x: internal.isDragging ? internal.dragOffsetX : internal.baseX
  y: internal.isDragging ? internal.dragOffsetY : internal.baseY

  // Apply scale to the widget from top-left corner
  scale: widgetScale
  transformOrigin: Item.TopLeft
  // Use smooth animation outside edit mode only
  Behavior on scale { enabled: !Settings.data.desktopWidgets.editMode; NumberAnimation { duration: 200; easing.type: Easing.InOutQuad; } }

  // Update base position from widgetData when not dragging
  onWidgetDataChanged: {
    if (!internal.isDragging) {
      internal.baseX = (widgetData && widgetData.x !== undefined) ? widgetData.x : defaultX;
      internal.baseY = (widgetData && widgetData.y !== undefined) ? widgetData.y : defaultY;
      // Update scale from widgetData if available
      if (widgetData && widgetData.scale !== undefined) {
        widgetScale = widgetData.scale;
      }
    }
  }

  // Edit mode decoration rectangle
  Rectangle {
    id: decorationRect
    anchors.fill: parent
    anchors.margins: -Style.marginS
    color: Settings.data.desktopWidgets.editMode ? Qt.rgba(Color.mPrimary.r, Color.mPrimary.g, Color.mPrimary.b, 0.1) : "transparent"
    border.color: (Settings.data.desktopWidgets.editMode || internal.isDragging) ?
                  (internal.isDragging ? Qt.rgba(textColor.r, textColor.g, textColor.b, 0.5) : Color.mPrimary) : "transparent"
    border.width: Settings.data.desktopWidgets.editMode ? 3 : (internal.isDragging ? 2 : 0)
    radius: Style.radiusL + Style.marginS
    z: -1
  }

  // Container with shadow
  Rectangle {
    id: container
    anchors.fill: parent
    radius: Style.radiusL
    color: Color.mSurface
    border {
      width: 1
      color: Qt.alpha(Color.mOutline, 0.12)
    }
    clip: true
    visible: root.showBackground

    layer.enabled: Settings.data.general.enableShadows && !internal.isDragging && root.showBackground
    layer.effect: MultiEffect {
      shadowEnabled: true
      shadowBlur: Style.shadowBlur * 1.5
      shadowOpacity: Style.shadowOpacity * 0.6
      shadowColor: Color.black
      shadowHorizontalOffset: Settings.data.general.shadowOffsetX
      shadowVerticalOffset: Settings.data.general.shadowOffsetY
      blurMax: Style.shadowBlurMax
    }
  }

  // Content slot
  Item {
    id: contentContainer
    anchors.fill: parent
    z: 1
  }


  // Drag and Scale MouseArea - handles both dragging (left-click) and scaling (right-click)
  MouseArea {
    id: interactionArea
    anchors.fill: parent
    z: 1000
    visible: Settings.data.desktopWidgets.editMode
    cursorShape: {
      if (internal.isDragging) return Qt.ClosedHandCursor;
      if (internal.isScaling) return Qt.SizeAllCursor;
      // Change cursor based on which button user is likely to press
      // Right mouse button for scaling, left for dragging
      return Qt.OpenHandCursor;
    }
    hoverEnabled: true
    acceptedButtons: Qt.LeftButton | Qt.RightButton

    property point pressPos: Qt.point(0, 0)
    property real initialScale: 1.0

    onPressed: mouse => {
      // If any operation is already in progress, don't start a new one
      if (internal.operationType !== "") {
        return;
      }

      pressPos = Qt.point(mouse.x, mouse.y);

      if (mouse.button === Qt.LeftButton) {
        // Start dragging
        internal.operationType = "drag";
        internal.dragOffsetX = root.x;
        internal.dragOffsetY = root.y;
        internal.isDragging = true;
      } else if (mouse.button === Qt.RightButton) {
        // Start scaling
        internal.operationType = "scale";
        internal.isScaling = true;
        internal.initialWidth = root.width;
        internal.initialHeight = root.height;
        internal.initialMousePos = Qt.point(mouse.x, mouse.y);
        internal.initialScale = root.widgetScale;
        internal.lastScale = root.widgetScale;
      }
    }

    onPositionChanged: mouse => {
      if (internal.isDragging && pressed && internal.operationType === "drag") {
        // Calculate the offset from the initial press position
        var globalPressPos = mapToItem(root.parent, pressPos.x, pressPos.y);
        var globalCurrentPos = mapToItem(root.parent, mouse.x, mouse.y);

        // Calculate the movement delta since the press
        var deltaX = globalCurrentPos.x - globalPressPos.x;
        var deltaY = globalCurrentPos.y - globalPressPos.y;

        // Calculate new position based on the original position when drag started
        var newX = internal.dragOffsetX + deltaX;
        var newY = internal.dragOffsetY + deltaY;

        // Boundary clamping - account for scaled widget size
        var scaledWidth = root.width * root.widgetScale;
        var scaledHeight = root.height * root.widgetScale;
        if (root.parent && scaledWidth > 0 && scaledHeight > 0) {
          newX = Math.max(0, Math.min(newX, root.parent.width - scaledWidth));
          newY = Math.max(0, Math.min(newY, root.parent.height - scaledHeight));
        }

        internal.dragOffsetX = newX;
        internal.dragOffsetY = newY;
      }
      else if (internal.isScaling && pressed && internal.operationType === "scale") {
        // Calculate relative movement from initial position
        var dx = mouse.x - internal.initialMousePos.x;
        var dy = mouse.y - internal.initialMousePos.y;

        // Calculate combined movement with a more nuanced approach
        // Use the primary direction of movement to determine scale change
        var primaryMovement = (Math.abs(dx) > Math.abs(dy)) ? dx : dy;

        // Calculate scale change based on movement relative to initial widget size
        // This ensures consistent behavior regardless of current scale level
        var scaleChange = primaryMovement * root.scaleSensitivity;

        // Calculate new scale with constraints (adding to last applied scale, not initial scale)
        var newScale = Math.max(minScale, Math.min(maxScale, internal.lastScale + scaleChange));

        // Apply smoothing by checking if the change is significant enough
        // Use a slightly higher threshold to prevent rapid changes
        if (Math.abs(root.widgetScale - newScale) > root.scaleUpdateThreshold &&
            !isNaN(newScale) &&
            newScale > 0) {
          root.widgetScale = newScale;
          internal.lastScale = newScale;
        }
      }
    }

    onReleased: mouse => {
      if (internal.isDragging && internal.operationType === "drag" && widgetIndex >= 0 && screen && screen.name) {
        // Update widget position using the helper function
        root.updateWidgetData({
          "x": internal.dragOffsetX,
          "y": internal.dragOffsetY
        });

        // Update base position to final position
        internal.baseX = internal.dragOffsetX;
        internal.baseY = internal.dragOffsetY;
        internal.isDragging = false;
        internal.operationType = "";
      }
      else if (internal.isScaling && internal.operationType === "scale") {
        // Update widget scale using the helper function
        root.updateWidgetData({
          "scale": root.widgetScale
        });

        internal.isScaling = false;
        internal.operationType = "";
        internal.lastScale = root.widgetScale;
      }
    }

    onCanceled: {
      internal.isDragging = false;
      internal.isScaling = false;
      internal.operationType = "";
      internal.lastScale = root.widgetScale;  // Sync lastScale with current scale when operation is canceled
    }
  }
}