DankMaterialShell/Modules/ControlCenter/NetworkTab.qml

import QtQuick
import QtQuick.Controls
import Quickshell
import Quickshell.Io
import Quickshell.Widgets
import qs.Common
import qs.Services
import qs.Widgets
import qs.Modules.ControlCenter.Network

Item {
    id: networkTab

    property var wifiPasswordModalRef: wifiPasswordModal
    property var networkInfoModalRef: networkInfoModal

    property var sortedWifiNetworks: {
        if (!NetworkService.wifiAvailable || !NetworkService.wifiEnabled) {
            return [];
        }
        
        var allNetworks = NetworkService.wifiNetworks;
        var savedNetworks = NetworkService.savedWifiNetworks;
        var currentSSID = NetworkService.currentWifiSSID;
        var signalStrength = NetworkService.wifiSignalStrength;
        var refreshTrigger = forceRefresh; // Force recalculation
        
        var networks = [...allNetworks];
        
        networks.forEach(function(network) {
            network.connected = (network.ssid === currentSSID);
            network.saved = savedNetworks.some(function(saved) {
                return saved.ssid === network.ssid;
            });
            if (network.connected && signalStrength) {
                network.signalStrength = signalStrength;
            }
        });
        
        networks.sort(function(a, b) {
            if (a.connected && !b.connected) return -1;
            if (!a.connected && b.connected) return 1;
            return b.signal - a.signal;
        });
        
        return networks;
    }

    property int forceRefresh: 0
    
    Connections {
        target: NetworkService
        function onNetworksUpdated() {
            forceRefresh++;
        }
    }
    
    Component.onCompleted: {
        NetworkService.addRef();
        NetworkService.autoRefreshEnabled = true;
        if (NetworkService.wifiEnabled)
            NetworkService.scanWifi();
        wifiMonitorTimer.start();
    }
    
    Component.onDestruction: {
        NetworkService.removeRef();
        NetworkService.autoRefreshEnabled = false;
    }

    Row {
        anchors.fill: parent
        spacing: Theme.spacingM

        Column {
            width: (parent.width - Theme.spacingM) / 2
            height: parent.height
            spacing: Theme.spacingS

            Flickable {
                width: parent.width
                height: parent.height - 30
                clip: true
                contentWidth: width
                contentHeight: wifiContent.height
                boundsBehavior: Flickable.DragAndOvershootBounds
                // Qt 6.9+ scrolling: flickDeceleration/maximumFlickVelocity only affect touch now
                flickDeceleration: 1500
                maximumFlickVelocity: 2000
                
                // Custom wheel handler for Qt 6.9+ responsive mouse wheel scrolling
                WheelHandler {
                    acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad
                    onWheel: (event) => {
                        let delta = event.pixelDelta.y !== 0 ? event.pixelDelta.y * 1.8 : event.angleDelta.y / 120 * 60
                        let newY = parent.contentY - delta
                        newY = Math.max(0, Math.min(parent.contentHeight - parent.height, newY))
                        parent.contentY = newY
                        event.accepted = true
                    }
                }

                Column {
                    id: wifiContent
                    width: parent.width
                    spacing: Theme.spacingM

                    WiFiCard {
                        refreshTimer: refreshTimer
                    }
                }

                ScrollBar.vertical: ScrollBar {
                    policy: ScrollBar.AsNeeded
                }
            }
        }

        Column {
            width: (parent.width - Theme.spacingM) / 2
            height: parent.height
            spacing: Theme.spacingS

            Flickable {
                width: parent.width
                height: parent.height - 30
                clip: true
                contentWidth: width
                contentHeight: ethernetContent.height
                boundsBehavior: Flickable.StopAtBounds
                // Qt 6.9+ scrolling: flickDeceleration/maximumFlickVelocity only affect touch now
                flickDeceleration: 1500
                maximumFlickVelocity: 2000
                
                // Custom wheel handler for Qt 6.9+ responsive mouse wheel scrolling
                WheelHandler {
                    acceptedDevices: PointerDevice.Mouse | PointerDevice.TouchPad
                    onWheel: (event) => {
                        let delta = event.pixelDelta.y !== 0 ? event.pixelDelta.y * 1.8 : event.angleDelta.y / 120 * 60
                        let newY = parent.contentY - delta
                        newY = Math.max(0, Math.min(parent.contentHeight - parent.height, newY))
                        parent.contentY = newY
                        event.accepted = true
                    }
                }

                Column {
                    id: ethernetContent
                    width: parent.width
                    spacing: Theme.spacingM

                    EthernetCard {
                    }
                }

                ScrollBar.vertical: ScrollBar {
                    policy: ScrollBar.AsNeeded
                }
            }
        }
    }

    Rectangle {
        anchors.top: parent.top
        anchors.topMargin: 100
        anchors.left: parent.left
        anchors.right: parent.right
        anchors.bottom: parent.bottom
        color: "transparent"
        visible: !NetworkService.wifiEnabled

        Column {
            anchors.centerIn: parent
            spacing: Theme.spacingM

            DankIcon {
                anchors.horizontalCenter: parent.horizontalCenter
                name: "wifi_off"
                size: 48
                color: Qt.rgba(Theme.surfaceText.r, Theme.surfaceText.g, Theme.surfaceText.b, 0.3)
            }

            StyledText {
                anchors.horizontalCenter: parent.horizontalCenter
                text: "WiFi is turned off"
                font.pixelSize: Theme.fontSizeLarge
                color: Qt.rgba(Theme.surfaceText.r, Theme.surfaceText.g, Theme.surfaceText.b, 0.6)
                font.weight: Font.Medium
            }

            StyledText {
                anchors.horizontalCenter: parent.horizontalCenter
                text: "Turn on WiFi to see networks"
                font.pixelSize: Theme.fontSizeMedium
                color: Qt.rgba(Theme.surfaceText.r, Theme.surfaceText.g, Theme.surfaceText.b, 0.4)
            }
        }
    }

    WiFiNetworksList {
        wifiContextMenuWindow: wifiContextMenuWindow
        sortedWifiNetworks: networkTab.sortedWifiNetworks
        wifiPasswordModalRef: networkTab.wifiPasswordModalRef
    }

    Timer {
        id: refreshTimer
        interval: 2000
        running: visible && refreshTimer.triggered
        property bool triggered: false
        onTriggered: {
            NetworkService.refreshNetworkStatus();
            if (NetworkService.wifiEnabled && !NetworkService.isScanning) {
                NetworkService.scanWifi();
            }
            triggered = false;
        }
    }

    Connections {
        target: NetworkService
        function onWifiEnabledChanged() {
            if (NetworkService.wifiEnabled && visible) {
                wifiScanDelayTimer.start();
                wifiMonitorTimer.start();
            } else {
                NetworkService.currentWifiSSID = "";
                NetworkService.wifiSignalStrength = "excellent";
                NetworkService.wifiNetworks = [];
                NetworkService.savedWifiNetworks = [];
                NetworkService.connectionStatus = "";
                NetworkService.connectingSSID = "";
                NetworkService.isScanning = false;
                NetworkService.refreshNetworkStatus();
                wifiMonitorTimer.stop();
            }
        }
    }

    Timer {
        id: wifiScanDelayTimer
        interval: 1500
        running: false
        repeat: false
        onTriggered: {
            if (NetworkService.wifiEnabled && visible) {
                if (!NetworkService.isScanning) {
                    NetworkService.scanWifi();
                } else {
                    wifiRetryTimer.start();
                }
            }
        }
    }

    Timer {
        id: wifiRetryTimer
        interval: 2000
        running: false
        repeat: false
        onTriggered: {
            if (NetworkService.wifiEnabled && visible && NetworkService.wifiNetworks.length === 0) {
                if (!NetworkService.isScanning) {
                    NetworkService.scanWifi();
                }
            }
        }
    }

    Timer {
        id: wifiMonitorTimer
        interval: 8000 // Check every 8 seconds
        running: false
        repeat: true
        onTriggered: {
            if (!visible || !NetworkService.wifiEnabled) {
                running = false;
                return;
            }

            var shouldScan = false;
            var reason = "";

            if (NetworkService.networkStatus !== "wifi") {
                shouldScan = true;
                reason = "not connected to WiFi";
            }
            else if (NetworkService.wifiNetworks.length === 0) {
                shouldScan = true;
                reason = "no networks cached";
            }

            if (shouldScan && !NetworkService.isScanning) {
                NetworkService.scanWifi();
            }
        }
    }

    onVisibleChanged: {
        if (visible && NetworkService.wifiEnabled) {
            wifiMonitorTimer.start();
        } else {
            wifiMonitorTimer.stop();
        }
    }

    WiFiContextMenu {
        id: wifiContextMenuWindow
        parentItem: networkTab
        wifiPasswordModalRef: networkTab.wifiPasswordModalRef
        networkInfoModalRef: networkTab.networkInfoModalRef
    }

    MouseArea {
        anchors.fill: parent
        visible: wifiContextMenuWindow.visible
        onClicked: {
            wifiContextMenuWindow.hide();
        }

        MouseArea {
            x: wifiContextMenuWindow.x
            y: wifiContextMenuWindow.y
            width: wifiContextMenuWindow.width
            height: wifiContextMenuWindow.height
            onClicked: {
            }
        }
    }
}