conrolcenter: debug/rewrite of wireless panel

1 files changed, 278 insertions, 5 deletions

diff --git a/modules/controlcenter/network/PasswordDialog.qml b/modules/controlcenter/network/PasswordDialog.qml
index fa4788c..7aa698b 100644
--- a/modules/controlcenter/network/PasswordDialog.qml
+++ b/modules/controlcenter/network/PasswordDialog.qml
@@ -14,11 +14,37 @@ Item {
     id: root
 
     required property Session session
-    readonly property var network: session.network.pendingNetwork
+    readonly property var network: {
+        // Try pendingNetwork first, then fall back to active network selection
+        if (session.network.pendingNetwork) {
+            return session.network.pendingNetwork;
+        }
+        // Fallback to active network if available
+        if (session.network.active) {
+            return session.network.active;
+        }
+        return null;
+    }
 
     visible: session.network.showPasswordDialog
     enabled: visible
     focus: visible
+    
+    // Ensure network is set when dialog opens
+    Component.onCompleted: {
+        if (visible && !session.network.pendingNetwork && session.network.active) {
+            session.network.pendingNetwork = session.network.active;
+        }
+    }
+    
+    Connections {
+        target: root
+        function onVisibleChanged(): void {
+            if (visible && !session.network.pendingNetwork && session.network.active) {
+                session.network.pendingNetwork = session.network.active;
+            }
+        }
+    }
 
     Keys.onEscapePressed: {
         root.session.network.showPasswordDialog = false;
@@ -105,6 +131,35 @@ Item {
                 font.pointSize: Appearance.font.size.small
             }
 
+            StyledText {
+                id: statusText
+                
+                Layout.alignment: Qt.AlignHCenter
+                Layout.topMargin: Appearance.spacing.small
+                visible: Network.connectionStatus.length > 0 || connectButton.connecting
+                text: {
+                    if (Network.connectionStatus.length > 0) {
+                        return Network.connectionStatus;
+                    } else if (connectButton.connecting) {
+                        return qsTr("Connecting...");
+                    }
+                    return "";
+                }
+                color: {
+                    const status = Network.connectionStatus;
+                    if (status.includes("Error") || status.includes("error") || status.includes("failed")) {
+                        return Colours.palette.m3error;
+                    } else if (status.includes("successful") || status.includes("Connected") || status.includes("success")) {
+                        return Colours.palette.m3primary;
+                    }
+                    return Colours.palette.m3onSurfaceVariant;
+                }
+                font.pointSize: Appearance.font.size.small
+                font.weight: (Network.connectionStatus.includes("Error") || Network.connectionStatus.includes("error")) ? 500 : 400
+                wrapMode: Text.WordWrap
+                Layout.maximumWidth: parent.width - Appearance.padding.large * 2
+            }
+
             Item {
                 Layout.topMargin: Appearance.spacing.large
                 Layout.fillWidth: true
@@ -145,9 +200,17 @@ Item {
                             if (root.visible) {
                                 passwordField.forceActiveFocus();
                                 passwordField.text = "";
+                                Network.connectionStatus = "";
                             }
                         }
                     }
+                    
+                    Connections {
+                        target: Network
+                        function onConnectionStatusChanged(): void {
+                            // Status updated, ensure it's visible
+                        }
+                    }
 
                     Keys.onReturnPressed: {
                         if (connectButton.enabled) {
@@ -190,12 +253,222 @@ Item {
                     text: qsTr("Connect")
                     enabled: passwordField.text.length > 0
 
+                    property bool connecting: false
+
                     function onClicked(): void {
-                        if (root.network && passwordField.text.length > 0) {
-                            Network.connectToNetwork(root.network.ssid, passwordField.text);
-                            root.session.network.showPasswordDialog = false;
-                            passwordField.text = "";
+                        Network.connectionStatus = "";
+                        
+                        // Get password first
+                        const password = passwordField.text;
+                        
+                        // Try multiple ways to get the network
+                        let networkToUse = null;
+                        
+                        // Try 1: root.network (computed property)
+                        if (root.network) {
+                            networkToUse = root.network;
+                        }
+                        
+                        // Try 2: pendingNetwork
+                        if (!networkToUse && root.session.network.pendingNetwork) {
+                            networkToUse = root.session.network.pendingNetwork;
+                        }
+                        
+                        // Try 3: active network
+                        if (!networkToUse && root.session.network.active) {
+                            networkToUse = root.session.network.active;
+                            root.session.network.pendingNetwork = networkToUse;
+                        }
+                        
+                        // Check all conditions
+                        const hasNetwork = !!networkToUse;
+                        const hasPassword = password && password.length > 0;
+                        const notConnecting = !connecting;
+                        
+                        if (hasNetwork && hasPassword && notConnecting) {
+                            // Set status immediately
+                            Network.connectionStatus = qsTr("Preparing to connect...");
+                            
+                            // Keep dialog open and track connection
+                            connecting = true;
+                            connectButton.enabled = false;
+                            connectButton.text = qsTr("Connecting...");
+                            
+                            // Force immediate UI update
+                            statusText.visible = true;
+                            
+                            // Store target SSID for later comparison
+                            const ssidToConnect = networkToUse.ssid || "";
+                            const bssidToConnect = networkToUse.bssid || "";
+                            
+                            // Store the SSID we're connecting to so we can compare later
+                            // even if root.network changes
+                            content.connectingToSsid = ssidToConnect;
+                            
+                            // Execute connection immediately
+                            Network.connectToNetwork(
+                                ssidToConnect, 
+                                password, 
+                                bssidToConnect,
+                                () => {
+                                    // Callback if connection fails - keep dialog open
+                                    connecting = false;
+                                    connectButton.enabled = true;
+                                    connectButton.text = qsTr("Connect");
+                                    content.connectingToSsid = "";  // Clear on failure
+                                }
+                            );
+                            
+                            // Start connection check timer immediately
+                            connectionCheckTimer.checkCount = 0;
+                            connectionCheckTimer.start();
+                            
+                            // Also check immediately after a short delay to catch quick connections
+                            Qt.callLater(() => {
+                                if (root.visible) {
+                                    closeDialogIfConnected();
+                                }
+                            });
+                        } else {
+                            // Show error in status
+                            Network.connectionStatus = qsTr("Error: Cannot connect - missing network or password");
+                        }
+                    }
+                }
+            }
+            
+            // Store the SSID we're connecting to when connection starts
+            property string connectingToSsid: ""
+            
+            property string targetSsid: {
+                // Track the SSID we're trying to connect to
+                // Prefer explicitly stored connectingToSsid, then computed values
+                if (connectingToSsid && connectingToSsid.length > 0) {
+                    return connectingToSsid;
+                }
+                if (root.network && root.network.ssid) {
+                    return root.network.ssid;
+                }
+                if (root.session.network.pendingNetwork && root.session.network.pendingNetwork.ssid) {
+                    return root.session.network.pendingNetwork.ssid;
+                }
+                return "";
+            }
+            
+            function closeDialogIfConnected(): bool {
+                // Check if we're connected to the network we're trying to connect to
+                const ssid = targetSsid;
+                
+                if (!ssid || ssid.length === 0) {
+                    return false;
+                }
+                
+                if (!Network.active) {
+                    return false;
+                }
+                
+                const activeSsid = Network.active.ssid || "";
+                
+                if (activeSsid === ssid) {
+                    // Connection succeeded - close dialog
+                    connectionCheckTimer.stop();
+                    aggressiveCheckTimer.stop();
+                    connectionCheckTimer.checkCount = 0;
+                    connectButton.connecting = false;
+                    Network.connectionStatus = "";
+                    root.session.network.showPasswordDialog = false;
+                    passwordField.text = "";
+                    content.connectingToSsid = "";  // Clear stored SSID
+                    return true;
+                }
+                return false;
+            }
+            
+            Timer {
+                id: connectionCheckTimer
+                interval: 1000  // Check every 1 second for faster response
+                repeat: true
+                triggeredOnStart: false
+                property int checkCount: 0
+                
+                onTriggered: {
+                    checkCount++;
+                    
+                    // Try to close dialog if connected
+                    const closed = content.closeDialogIfConnected();
+                    if (closed) {
+                        return;
+                    }
+                    
+                    if (connectButton.connecting) {
+                        // Still connecting, check again
+                        // Limit to 20 checks (20 seconds total)
+                        if (checkCount >= 20) {
+                            connectionCheckTimer.stop();
+                            connectionCheckTimer.checkCount = 0;
+                            connectButton.connecting = false;
+                            connectButton.enabled = true;
+                            connectButton.text = qsTr("Connect");
+                        }
+                    } else {
+                        // Not connecting anymore, stop timer
+                        connectionCheckTimer.stop();
+                        connectionCheckTimer.checkCount = 0;
+                    }
+                }
+            }
+            
+            Connections {
+                target: Network
+                function onActiveChanged(): void {
+                    // Check immediately when active network changes
+                    if (root.visible) {
+                        // Check immediately - if connected, close right away
+                        if (content.closeDialogIfConnected()) {
+                            return;
+                        }
+                        
+                        // Also check after a delay in case the active network isn't fully updated yet
+                        Qt.callLater(() => {
+                            if (root.visible) {
+                                content.closeDialogIfConnected();
+                            }
+                        });
+                    }
+                }
+            }
+            
+            // Also check when dialog becomes visible
+            Connections {
+                target: root
+                function onVisibleChanged(): void {
+                    if (root.visible) {
+                        // Check immediately when dialog opens
+                        Qt.callLater(() => {
+                            if (root.visible) {
+                                closeDialogIfConnected();
+                            }
+                        });
+                    }
+                }
+            }
+            
+            // Aggressive polling timer - checks every 500ms when dialog is visible and connecting
+            // This ensures we catch the connection even if signals are missed
+            Timer {
+                id: aggressiveCheckTimer
+                interval: 500
+                repeat: true
+                running: root.visible && connectButton.connecting
+                triggeredOnStart: true
+                
+                onTriggered: {
+                    if (root.visible && connectButton.connecting) {
+                        if (content.closeDialogIfConnected()) {
+                            stop();
                         }
+                    } else {
+                        stop();
                     }
                 }
             }