Merge commit '18f05cc52dfb7889853a4f84aad975309ab7dbbe' into release

ks_includes/sdbus_nm.py

@@ -175,23 +175,32 @@ class SdbusNm:
         networks = []
         try:
             if self.wlan_device:
+                seen_networks = {}
                 all_aps = [AccessPoint(result) for result in self.wlan_device.access_points]
-                networks.extend(
+                for ap in all_aps:
-                    {
+                    if not ap.ssid:
-                        "SSID": ap.ssid.decode("utf-8"),
+                        continue
-                        "known": self.is_known(ap.ssid.decode("utf-8")),
+
-                        "security": get_encryption(
+                    ssid = ap.ssid.decode("utf-8")
-                            ap.rsn_flags or ap.wpa_flags or ap.flags
+                    signal_level = ap.strength
-                        ),
+                    if ssid in seen_networks:
-                        "frequency": WifiChannels(ap.frequency)[0],
+                        if signal_level > seen_networks[ssid]["signal_level"]:
-                        "channel": WifiChannels(ap.frequency)[1],
+                            seen_networks[ssid] = {
-                        "signal_level": ap.strength,
+                                "SSID": ssid,
-                        "max_bitrate": ap.max_bitrate,
+                                "known": self.is_known(ssid),
-                        "BSSID": ap.hw_address,
+                                "security": get_encryption(ap.rsn_flags or ap.wpa_flags or ap.flags),
-                    }
+                                "signal_level": signal_level,
-                    for ap in all_aps
+                                "BSSID": ap.hw_address,
-                    if ap.ssid
+                            }
-                )
+                    else:
+                        seen_networks[ssid] = {
+                            "SSID": ssid,
+                            "known": self.is_known(ssid),
+                            "security": get_encryption(ap.rsn_flags or ap.wpa_flags or ap.flags),
+                            "signal_level": signal_level,
+                            "BSSID": ap.hw_address,
+                        }
+                networks = list(seen_networks.values())
                 return sorted(networks, key=lambda i: i["signal_level"], reverse=True)
             return networks
         except Exception as e:
@@ -200,6 +209,15 @@ class SdbusNm:
     def get_bssid_from_ssid(self, ssid):
         return next(net["BSSID"] for net in self.get_networks() if ssid == net["SSID"])
 
+    def get_is_connected(self):
+        state = self.wlan_device.state
+        if state in [
+            enums.DeviceState.ACTIVATED,
+        ]:
+            return True
+        else:
+            return False
+
     def get_connected_ap(self):
         if self.wlan_device.active_access_point == "/":
             return None
@@ -248,9 +266,7 @@ class SdbusNm:
         }
 
         if security_type == "Open":
-            properties["802-11-wireless-security"] = {
+            properties["802-11-wireless"]["security"] = ("s", "none")
-                "key-mgmt": ("s", "none"),
-            }
         elif "WPA-PSK" in security_type:
             properties["802-11-wireless-security"] = {
                 "key-mgmt": ("s", "wpa-psk"),
@@ -350,8 +366,6 @@ class SdbusNm:
 
     def connect(self, ssid):
         if target_connection := self.get_connection_path_by_ssid(ssid):
-            message = ssid + "\n" + _("Starting WiFi Association")
-            self.popup(message, 1)
             try:
                 active_connection = self.nm.activate_connection(target_connection)
                 return target_connection

panels/network.py

@@ -42,19 +42,28 @@ class Panel(ScreenPanel):
             self.content.add(self.error_box)
             self._screen.panels_reinit.append(self._screen._cur_panels[-1])
             return
-        self.update_timeout = None
+        self.reload_timer_id = None
-        self.conn_status = None
+        self.monitor_timer_id = None
+        self.delay_reload_timer_id = None
         self.init_status = False
         self.reload = False
-        self.last_ap_bssid = ''
+        self.last_state = None
-        self.network_list = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, hexpand=True, vexpand=True)
+        self.network_list = Gtk.ListBox(selection_mode=Gtk.SelectionMode.NONE)
         self.network_rows = {}
         self.networks = {}
         self.wifi_signal_icons = {
-            'excellent': self._gtk.PixbufFromIcon('wifi_excellent'),
+            "excellent": self._gtk.PixbufFromIcon(
-            'good': self._gtk.PixbufFromIcon('wifi_good'),
+                "wifi_excellent", width=self._gtk.content_width * 0.06, height=self._gtk.content_height * 0.06
-            'fair': self._gtk.PixbufFromIcon('wifi_fair'),
+            ),
-            'weak': self._gtk.PixbufFromIcon('wifi_weak'),
+            "good": self._gtk.PixbufFromIcon(
+                "wifi_good", width=self._gtk.content_width * 0.06, height=self._gtk.content_height * 0.06
+            ),
+            "fair": self._gtk.PixbufFromIcon(
+                "wifi_fair", width=self._gtk.content_width * 0.06, height=self._gtk.content_height * 0.06
+            ),
+            "weak": self._gtk.PixbufFromIcon(
+                "wifi_weak", width=self._gtk.content_width * 0.06, height=self._gtk.content_height * 0.06
+            ),
         }
 
         self.network_interfaces = self.sdbus_nm.get_interfaces()
@@ -74,7 +83,6 @@ class Panel(ScreenPanel):
 
         self.reload_button = self._gtk.Button("refresh", None, "custom-icon-button", self.bts)
         self.reload_button.set_no_show_all(True)
-        self.reload_button.show()
         self.reload_button.connect("clicked", self.reload_networks)
         self.reload_button.set_hexpand(False)
 
@@ -96,82 +104,103 @@ class Panel(ScreenPanel):
 
         if self.sdbus_nm.wifi:
             self.labels['main_box'].pack_start(sbox, False, False, 5)
-            GLib.idle_add(self.load_networks)
             scroll.add(self.network_list)
-            self.sdbus_nm.enable_monitoring(True)
+            if self.sdbus_nm.nm.wireless_enabled:
-            self.conn_status = GLib.timeout_add_seconds(1, self.sdbus_nm.monitor_connection_status)
+                self.reload_button.show()
+                self.sdbus_nm.enable_monitoring(True)
+                self.monitor_timer_id = GLib.timeout_add(500, self.sdbus_nm.monitor_connection_status)
         else:
             self._screen.show_popup_message(_("No wireless interface has been found"), level=2)
-            self.labels['networkinfo'] = Gtk.Label()
+            self.labels["networkinfo"] = Gtk.Label()
-            scroll.add(self.labels['networkinfo'])
+            scroll.add(self.labels["networkinfo"])
             self.update_single_network_info()
 
-        self.labels['main_box'].pack_start(scroll, True, True, 0)
+        self.labels["main_box"].pack_start(scroll, True, True, 0)
-        self.content.add(self.labels['main_box'])
+        self.content.add(self.labels["main_box"])
+        self.network_list.connect("row-activated", self.handle_wifi_selection)
 
     def popup_callback(self, msg, level=3):
-        self._screen.show_popup_message(msg, level)
+        if not self.refresh_status(msg):
+            for item in self.network_rows:
+                if self.network_rows[item]["label_state"] is not None:
+                    self.network_rows[item]["label_state"].set_no_show_all(True)
+                    self.network_rows[item]["label_state"].hide()
+            self._screen.show_popup_message(msg, level)
+
+    def handle_wifi_selection(self, list_box, row):
+        index = row.get_index()
+        logging.info(f"clicked SSID is {self.networks[index]['SSID']}")
+        self.connect_network(list_box, self.networks[index]["SSID"])
+
+    def add_network_item(self, ssid, lock, known, signal):
+        self.network_rows[ssid] = {}
+        self.network_rows[ssid]["row"] = Gtk.ListBoxRow()
+        self.network_rows[ssid]["hbox"] = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=15)
+        self.network_rows[ssid]["row"].add(self.network_rows[ssid]["hbox"])
+        self.network_rows[ssid]["row"].get_style_context().add_class("frame-item")
+
+        self.network_rows[ssid]["signal_ico"] = self._gtk.Image()
+        self.network_rows[ssid]["signal_ico"].set_from_pixbuf(self.get_signal_strength_icon(signal))
+        self.network_rows[ssid]["signal_ico"].set_margin_start(50)
+        self.network_rows[ssid]["hbox"].pack_start(self.network_rows[ssid]["signal_ico"], False, True, 20)
+
+        self.network_rows[ssid]["label_box"] = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+        self.network_rows[ssid]["label_ssid"] = Gtk.Label(label=ssid, xalign=0)
+        self.network_rows[ssid]["label_state"] = Gtk.Label(label="", xalign=0)
+        self.network_rows[ssid]["label_state"].set_ellipsize(Pango.EllipsizeMode.END)
+        self.network_rows[ssid]["label_state"].set_no_show_all(True)
+        self.network_rows[ssid]["label_box"].pack_start(self.network_rows[ssid]["label_ssid"], True, False, 0)
+        self.network_rows[ssid]["label_box"].pack_start(self.network_rows[ssid]["label_state"], True, False, 0)
+        self.network_rows[ssid]["hbox"].pack_start(self.network_rows[ssid]["label_box"], False, True, 10)
+
+        if known:
+            self.network_rows[ssid]["delete"] = self._gtk.Button("delete", None, "custom-icon-button", self.bts)
+            self.network_rows[ssid]["delete"].connect("clicked", self.remove_confirm_dialog, ssid, ssid)
+            self.network_rows[ssid]["delete"].set_hexpand(False)
+            self.network_rows[ssid]["delete"].set_halign(Gtk.Align.END)
+            self.network_rows[ssid]["hbox"].pack_end(self.network_rows[ssid]["delete"], False, True, 10)
+
+        if "Open" not in lock:
+            self.network_rows[ssid]["lock_image"] = self._gtk.Image(
+                "lock", self._gtk.content_width * 0.04, self._gtk.content_height * 0.04
+            )
+            self.network_rows[ssid]["lock_image"].set_hexpand(False)
+            self.network_rows[ssid]["lock_image"].set_halign(Gtk.Align.END)
+            self.network_rows[ssid]["hbox"].pack_end(self.network_rows[ssid]["lock_image"], False, True, 10)
+
+        self.network_rows[ssid]["hbox"].set_margin_end(50)
+        self.network_list.add(self.network_rows[ssid]["row"])
+
+    def move_network_to_front(self, networks, target_name):
+        if not target_name or (networks and networks[0].get("SSID") == target_name):
+            return networks
+        target_index = next((i for i, network in enumerate(networks) if network.get("SSID") == target_name), None)
+        if target_index is not None:
+            target_network = networks.pop(target_index)
+            networks.insert(0, target_network)
+        return networks
 
     def load_networks(self):
-        GLib.timeout_add_seconds(10, self._gtk.Button_busy, self.reload_button, False)
+        self.connected_ap = self.sdbus_nm.get_connected_ap()
-        self.content.show_all()
+        ap_ssid = None
-        return False
+        if self.connected_ap:
+            ap_ssid = self.connected_ap.ssid.decode("utf-8")
+        self.networks = self.move_network_to_front(self.sdbus_nm.get_networks(), ap_ssid)
+        if self.last_state != self.sdbus_nm.wifi_state:
+            self.last_state = self.sdbus_nm.wifi_state
+            self.sdbus_nm.wifi_state = -1
+            self.sdbus_nm.monitor_connection_status()
 
-    def add_network(self, bssid):
+        for item in self.networks:
-        if bssid in self.network_rows:
+            ssid = item.get("SSID")
-            return
+            if ssid:
-
+                self.add_network_item(
-        networks = self.sdbus_nm.get_networks()
+                    ssid,
-        if networks:
+                    item.get("security", "unknown"),
-            net = next((net for net in networks if bssid == net['BSSID']), None)
+                    item.get("known", False),
-        if net is None:
+                    item.get("signal_level", 0),
-            self.remove_network_from_list(bssid)
+                )
-            return
+        self.network_list.show_all()
-
-        ssid = net['SSID']
-
-        connect = self._gtk.Button("load", None, "color3", self.bts)
-        connect.connect("clicked", self.connect_network, ssid)
-        connect.set_hexpand(False)
-        connect.set_halign(Gtk.Align.END)
-
-        delete = self._gtk.Button("delete", None, "color3", self.bts)
-        delete.connect("clicked", self.remove_confirm_dialog, ssid, bssid)
-        delete.set_hexpand(False)
-        delete.set_halign(Gtk.Align.END)
-
-        buttons = Gtk.Box(spacing=5)
-
-        name = Gtk.Label(hexpand=True, halign=Gtk.Align.START, wrap=True, wrap_mode=Pango.WrapMode.WORD_CHAR)
-        if bssid == self.sdbus_nm.get_connected_bssid():
-            ssid += ' (' + _("Connected") + ')'
-            name.set_markup(f"<big><b>{ssid}</b></big>")
-        else:
-            name.set_markup(f"<b>{ssid}</b>")
-        if net['known']:
-            buttons.add(delete)
-        buttons.add(connect)
-
-        labels = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, vexpand=True,
-                         halign=Gtk.Align.START, valign=Gtk.Align.CENTER)
-        labels.add(name)
-        icon = self._gtk.Image()
-
-        self.network_rows[bssid] = Gtk.Box(spacing=5, hexpand=True, vexpand=False)
-        self.network_rows[bssid].get_style_context().add_class("frame-item")
-        self.network_rows[bssid].add(icon)
-        self.network_rows[bssid].add(labels)
-        self.network_rows[bssid].add(buttons)
-
-        self.networks[bssid] = {
-            "connect": connect,
-            "delete": delete,
-            "icon": icon,
-            "name": name,
-            "row": self.network_rows[bssid],
-        }
-
-        self.network_list.add(self.network_rows[bssid])
 
     def remove_confirm_dialog(self, widget, ssid, bssid):
 
@@ -189,21 +218,20 @@ class Panel(ScreenPanel):
         self._gtk.remove_dialog(dialog)
         if response_id == Gtk.ResponseType.CANCEL:
             return
-        bssid = self.sdbus_nm.get_bssid_from_ssid(ssid)
-        self.remove_network_from_list(bssid)
         if response_id == Gtk.ResponseType.OK:
             logging.info(f"Deleting {ssid}")
             self.sdbus_nm.delete_network(ssid)
         if response_id == Gtk.ResponseType.APPLY:
             logging.info(f"Disconnecting {ssid}")
             self.sdbus_nm.disconnect_network()
+        self.delay_reload_networks(100)
 
     def add_new_network(self, widget, ssid):
         self._screen.remove_keyboard()
-        psk = self.labels['network_psk'].get_text()
+        psk = self.labels["network_psk"].get_text()
-        identity = self.labels['network_identity'].get_text()
+        identity = self.labels["network_identity"].get_text()
-        eap_method = self.get_dropdown_value(self.labels['network_eap_method'])
+        eap_method = self.get_dropdown_value(self.labels["network_eap_method"])
-        phase2 = self.get_dropdown_value(self.labels['network_phase2'])
+        phase2 = self.get_dropdown_value(self.labels["network_phase2"])
         logging.debug(f"{phase2=}")
         logging.debug(f"{eap_method=}")
         result = self.sdbus_nm.add_network(ssid, psk, eap_method, identity, phase2)
@@ -240,36 +268,37 @@ class Panel(ScreenPanel):
                 del self.labels[i]
         self.show_add = False
 
+    def get_network_index(self, ssid):
+        for index, network in enumerate(self.networks):
+            if network.get("SSID") == ssid:
+                return index
+        return -1
+
     def connect_network(self, widget, ssid, showadd=True):
-        self.deactivate()
+        index = self.get_network_index(ssid)
-        if showadd and not self.sdbus_nm.is_known(ssid):
+        ssid = self.networks[index]["SSID"]
-            sec_type = self.sdbus_nm.get_security_type(ssid)
+        if showadd and not self.networks[index]["known"]:  # self.sdbus_nm.is_known(ssid):
+            sec_type = self.networks[index]["security"]  # self.sdbus_nm.get_security_type(ssid)
             if sec_type == "Open" or "OWE" in sec_type:
                 logging.debug("Network is Open do not show psk")
-                result = self.sdbus_nm.add_network(ssid, '')
+                result = self.sdbus_nm.add_network(ssid, "", "")
+                self.sdbus_nm.connect(ssid)
                 if "error" in result:
                     self._screen.show_popup_message(result["message"])
             else:
                 self.show_add_network(widget, ssid)
-            self.activate()
             return
-        bssid = self.sdbus_nm.get_bssid_from_ssid(ssid)
-        if bssid and bssid in self.network_rows:
-            self.remove_network_from_list(bssid)
         self.sdbus_nm.connect(ssid)
-        self.reload_networks()
+        self.delay_reload_networks(1000)
-        if self.conn_status is None:
+        if self.monitor_timer_id is None:
             self.sdbus_nm.enable_monitoring(True)
-            self.conn_status = GLib.timeout_add(500, self.sdbus_nm.monitor_connection_status)
+            self.monitor_timer_id = GLib.timeout_add(500, self.sdbus_nm.monitor_connection_status)
 
-    def remove_network_from_list(self, bssid):
+    def remove_network_list(self):
-        if bssid not in self.network_rows:
+        for row in self.network_list.get_children():
-            logging.error(f"{bssid} not in rows")
+            self.network_list.remove(row)
-            return
+            row.destroy()
-        self.network_list.remove(self.network_rows[bssid])
+        self.network_rows.clear()
-        del self.network_rows[bssid]
-        del self.networks[bssid]
-        return
 
     def show_add_network(self, widget, ssid):
         if self.show_add:
@@ -277,174 +306,161 @@ class Panel(ScreenPanel):
 
         for child in self.content.get_children():
             self.content.remove(child)
-
         if "add_network" in self.labels:
-            del self.labels['add_network']
+            del self.labels["add_network"]
-
         eap_method = Gtk.ComboBoxText(hexpand=True)
         for method in ("peap", "ttls", "pwd", "leap", "md5"):
             eap_method.append(method, method.upper())
-        self.labels['network_eap_method'] = eap_method
+        self.labels["network_eap_method"] = eap_method
         eap_method.set_active(0)
 
         phase2 = Gtk.ComboBoxText(hexpand=True)
         for method in ("mschapv2", "gtc", "pap", "chap", "mschap", "disabled"):
             phase2.append(method, method.upper())
-        self.labels['network_phase2'] = phase2
+        self.labels["network_phase2"] = phase2
         phase2.set_active(0)
 
-        auth_selection_box = Gtk.Box(no_show_all=True)
+        self.labels["network_identity"] = Gtk.Entry(hexpand=True, no_show_all=True)
-        auth_selection_box.add(self.labels['network_eap_method'])
+        self.labels["network_identity"].connect("focus-in-event", self._screen.show_keyboard)
-        auth_selection_box.add(self.labels['network_phase2'])
 
-        self.labels['network_identity'] = Gtk.Entry(hexpand=True, no_show_all=True)
+        self.labels["network_psk"] = Gtk.Entry(hexpand=True)
-        self.labels['network_identity'].connect("focus-in-event", self._screen.show_keyboard)
+        self.labels["network_psk"].set_visibility(False)
+        self.labels["network_psk"].connect("activate", self.add_new_network, ssid)
+        self.labels["network_psk"].connect("focus-in-event", self._screen.show_keyboard)
 
-        self.labels['network_psk'] = Gtk.Entry(hexpand=True)
+        save = self._gtk.Button("load", style="color3")
-        self.labels['network_psk'].connect("activate", self.add_new_network, ssid)
-        self.labels['network_psk'].connect("focus-in-event", self._screen.show_keyboard)
-
-        save = self._gtk.Button("sd", _("Save"), "color3")
         save.set_hexpand(False)
         save.connect("clicked", self.add_new_network, ssid)
 
         user_label = Gtk.Label(label=_("User"), hexpand=False, no_show_all=True)
         auth_grid = Gtk.Grid()
         auth_grid.attach(user_label, 0, 0, 1, 1)
-        auth_grid.attach(self.labels['network_identity'], 1, 0, 1, 1)
+        auth_grid.attach(self.labels["network_identity"], 1, 0, 1, 1)
         auth_grid.attach(Gtk.Label(label=_("Password"), hexpand=False), 0, 1, 1, 1)
-        auth_grid.attach(self.labels['network_psk'], 1, 1, 1, 1)
+        auth_grid.attach(self.labels["network_psk"], 1, 1, 1, 1)
         auth_grid.attach(save, 2, 0, 1, 2)
 
-        if "802.1x" in self.sdbus_nm.get_security_type(ssid):
+        self.labels["add_network"] = Gtk.Box(
-            user_label.show()
+            orientation=Gtk.Orientation.VERTICAL, spacing=5, valign=Gtk.Align.CENTER, hexpand=True, vexpand=True
-            self.labels['network_eap_method'].show()
-            self.labels['network_phase2'].show()
-            self.labels['network_identity'].show()
-            auth_selection_box.show()
-
-        self.labels['add_network'] = Gtk.Box(
-            orientation=Gtk.Orientation.VERTICAL, spacing=5, valign=Gtk.Align.CENTER,
-            hexpand=True, vexpand=True
         )
-        self.labels['add_network'].add(Gtk.Label(label=_("Connecting to %s") % ssid))
+        self.labels["add_network"].add(Gtk.Label(label=_("Connecting to %s") % ssid))
-        self.labels['add_network'].add(auth_selection_box)
+        self.labels["add_network"].add(auth_grid)
-        self.labels['add_network'].add(auth_grid)
         scroll = self._gtk.ScrolledWindow()
-        scroll.add(self.labels['add_network'])
+        scroll.add(self.labels["add_network"])
         self.content.add(scroll)
-        self.labels['network_psk'].grab_focus_without_selecting()
+        self.labels["network_psk"].grab_focus_without_selecting()
         self.content.show_all()
         self.show_add = True
 
-    def update_all_networks(self):
-        self.ap_bssid = self.sdbus_nm.get_connected_bssid()
-        if self.last_ap_bssid != self.ap_bssid:
-            self.remove_network_from_list(self.last_ap_bssid)
-            self.remove_network_from_list(self.ap_bssid)
-            self.last_ap_bssid = self.ap_bssid
-
-        if self.reload:
-            for child in self.network_list.get_children():
-                self.network_list.remove(child)
-            self.reload = False
-
-        self.interface = self.sdbus_nm.get_primary_interface()
-        self.labels['interface'].set_text(_("Interface") + f': {self.interface}')
-        self.labels['ip'].set_text(f"IP: {self.sdbus_nm.get_ip_address()}")
-        nets = self.sdbus_nm.get_networks()
-        remove = [bssid for bssid in self.network_rows.keys() if bssid not in [net['BSSID'] for net in nets]]
-        for bssid in remove:
-            self.remove_network_from_list(bssid)
-        for net in nets:
-            if net['BSSID'] not in self.network_rows.keys():
-                self.add_network(net['BSSID'])
-            self.update_network_info(net)
-        for i, net in enumerate(nets):
-            for child in self.network_list.get_children():
-                if 'BSSID' in net and net['BSSID'] in self.network_rows:
-                    if child == self.network_rows[net['BSSID']]:
-                        self.network_list.reorder_child(child, i)
-        self.network_list.show_all()
-        return True
-
-    def update_network_info(self, net):
-        if net['BSSID'] not in self.network_rows.keys() or net['BSSID'] not in self.networks:
-            logging.info(f"Unknown SSID {net['SSID']}")
-            return
-        self.networks[net['BSSID']]['icon'].set_from_pixbuf(self.get_signal_strength_icon(net["signal_level"]))
-
     def get_signal_strength_icon(self, signal_level):
         # networkmanager uses percentage not dbm
         if signal_level > 75:
-            return self.wifi_signal_icons['excellent']
+            return self.wifi_signal_icons["excellent"]
         elif signal_level > 60:
-            return self.wifi_signal_icons['good']
+            return self.wifi_signal_icons["good"]
         elif signal_level > 30:
-            return self.wifi_signal_icons['fair']
+            return self.wifi_signal_icons["fair"]
         else:
-            return self.wifi_signal_icons['weak']
+            return self.wifi_signal_icons["weak"]
 
-    def update_single_network_info(self):
+    def refresh_status(self, state=None):
-        self.labels['networkinfo'].set_markup(
+        if state:
-            f'<b>{self.interface}</b>\n\n'
+            self.connected_ap = self.sdbus_nm.get_connected_ap()
-            + '<b>' + _("Hostname") + f':</b> {os.uname().nodename}\n'
+            if self.connected_ap:
-            f'<b>IPv4:</b> {self.sdbus_nm.get_ip_address()}\n'
+                ap_ssid = self.connected_ap.ssid.decode("utf-8")
-        )
+                self.set_connect_state(ap_ssid, state)
-        self.labels['networkinfo'].show_all()
+                return True
-        return True
+            else:
+                return False
+
+    def set_connect_state(self, ssid, state):
+        for item in self.network_rows:
+            if self.network_rows[item]["label_state"] is not None:
+                self.network_rows[item]["label_state"].set_no_show_all(True)
+                self.network_rows[item]["label_state"].hide()
+        if ssid and state and ssid in self.network_rows:
+            if self.network_rows[ssid]["label_state"] is not None:
+                self.network_rows[ssid]["label_state"].set_markup(f'<span color="gray" size="small">{state}</span>')
+                self.network_rows[ssid]["label_state"].set_no_show_all(False)
+        self.network_list.show_all()
 
     def reload_networks(self, widget=None):
-        self.deactivate()
+        if self.reload:
+            return
+        self.reload = True
+        self.remove_network_list()
         del self.network_rows
         self.network_rows = {}
         if self.sdbus_nm is not None and self.sdbus_nm.wifi:
-            if widget:
+            self._gtk.Button_busy(self.reload_button, True)
-                self._gtk.Button_busy(widget, True)
             if not self.init_status:
                 self.sdbus_nm.rescan()
             else:
                 self.init_status = False
             self.load_networks()
-        self.activate()
+        if self.sdbus_nm.get_is_connected():
-        self.reload = True
+            self.refresh_status(_('Network connected'))
+
+        self._gtk.Button_busy(self.reload_button, False)
+        self.reload = False
+
+        if self.delay_reload_timer_id:
+            GLib.source_remove(self.delay_reload_timer_id)
+            self.delay_reload_timer_id = None
+
+        return self.sdbus_nm.nm.wireless_enabled
+
+    def delay_reload_networks(self, s):
+        self._gtk.Button_busy(self.reload_button, True)
+        if not self.delay_reload_timer_id:
+            self.delay_reload_timer_id = GLib.timeout_add(s, self.reload_networks)
+
+    def start_refresh_timer(self):
+        if not self.sdbus_nm.monitor_connection_status():
+            self.sdbus_nm.enable_monitoring(True)
+        if self.monitor_timer_id is None:
+            self.monitor_timer_id = GLib.timeout_add(600, self.sdbus_nm.monitor_connection_status)
+        if self.reload_timer_id is None:
+            self.reload_timer_id = GLib.timeout_add_seconds(10, self.reload_networks)
+        return False
+
+    def stop_refresh_timer(self):
+        if self.monitor_timer_id is not None:
+            self.sdbus_nm.enable_monitoring(False)
+            GLib.source_remove(self.monitor_timer_id)
+            self.monitor_timer_id = None
+        if self.reload_timer_id is not None:
+            GLib.source_remove(self.reload_timer_id)
+            self.reload_timer_id = None
 
     def activate(self):
         if self.sdbus_nm is None:
             return
-        if self.update_timeout is None:
+        if self.sdbus_nm.wifi:
-            if self.sdbus_nm.wifi:
+            if self.sdbus_nm.is_wifi_enabled():
-                if self.sdbus_nm.is_wifi_enabled():
+                self.delay_reload_networks(1000)
-                    if self.reload_button.get_sensitive():
+                self.start_refresh_timer()
-                        self._gtk.Button_busy(self.reload_button, True)
-                        self.sdbus_nm.rescan()
-                        self.load_networks()
-                self.update_timeout = GLib.timeout_add_seconds(5, self.update_all_networks)
-            else:
-                self.update_single_network_info()
-                self.update_timeout = GLib.timeout_add_seconds(5, self.update_single_network_info)
 
     def deactivate(self):
         if self.sdbus_nm is None:
             return
-        if self.update_timeout is not None:
+        self.stop_refresh_timer()
-            GLib.source_remove(self.update_timeout)
-            self.update_timeout = None
-        if self.sdbus_nm.wifi:
-            self.sdbus_nm.enable_monitoring(False)
-        if self.conn_status is not None:
-            GLib.source_remove(self.conn_status)
-            self.conn_status = None
 
     def toggle_wifi(self, switch, gparams):
         enable = switch.get_active()
         logging.info(f"WiFi {enable}")
         self.sdbus_nm.toggle_wifi(enable)
         if enable:
+            self.reload_button.set_no_show_all(False)
             self.reload_button.show()
+            self.network_list.set_no_show_all(False)
             self.network_list.show()
             self.init_status = True
-            self.reload_networks(self.reload_button)
+            self.delay_reload_networks(3000)
+            self.start_refresh_timer()
         else:
+            self.stop_refresh_timer()
+            self.reload_button.set_no_show_all(True)
             self.reload_button.hide()
+            self.network_list.set_no_show_all(True)
             self.network_list.hide()

panels/system.py

@@ -18,8 +18,8 @@ class Panel(ScreenPanel):
         self.labels = {}
         self.click_count = 0
         self.last_click_time = 0
-        self.click_threshold = 0.2
+        self.click_threshold = 2.0
-        self.target_clicks = 10
+        self.target_clicks = 5
         self.grid = Gtk.Grid(column_spacing=10, row_spacing=5)
 
         self.sysinfo = screen.printer.system_info

styles/dark/style.css

@@ -33,6 +33,7 @@
     color: @yellow-opa-100;
 }
 
+list,
 list row,
 treeview.view,
 window {
@@ -105,6 +106,18 @@ button.invalid:active,
     border-color: @blue-opa-50;
 }
 
+button.color1:hover,
+button.color2:hover,
+button.color3:hover,
+button.color4:hover,
+button.update:hover,
+button.invalid:hover,
+.dialog button:hover,
+row:hover {
+    background-color: @blue-opa-50;
+    border-color: @blue-opa-50;
+}
+
 button.active {
     background-color: @white-opa-20;
 }

styles/light/style.css

@@ -19,6 +19,7 @@
     color: @text ;
 }
 
+list,
 list row,
 treeview.view,
 window {
@@ -117,6 +118,17 @@ button.invalid:active,
     background-color: @active;
 }
 
+row:hover,
+button.color1:hover,
+button.color2:hover,
+button.color3:hover,
+button.color4:hover,
+button.update:hover,
+button.invalid:hover,
+.dialog button:hover {
+    background-color: @active;
+}
+
 button.active {
     background-color: @active;
 }