CreatBot/CreatBotKlipperScreen
7
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge commit '18f05cc52dfb7889853a4f84aad975309ab7dbbe' into release

Browse Source
This commit is contained in:
张开科 2025-02-14 15:21:36 +08:00
commit 2dba9f8ee2
5 changed files with 284 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
ks_includes/sdbus_nm.py
View File

@ -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(
{
"SSID": ap.ssid.decode("utf-8"),
"known": self.is_known(ap.ssid.decode("utf-8")),
"security": get_encryption(
ap.rsn_flags or ap.wpa_flags or ap.flags
),
"frequency": WifiChannels(ap.frequency)[0],
"channel": WifiChannels(ap.frequency)[1],
"signal_level": ap.strength,
"max_bitrate": ap.max_bitrate,
"BSSID": ap.hw_address,
}
for ap in all_aps
if ap.ssid
)
for ap in all_aps:
if not ap.ssid:
continue
ssid = ap.ssid.decode("utf-8")
signal_level = ap.strength
if ssid in seen_networks:
if signal_level > seen_networks[ssid]["signal_level"]:
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,
}
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"] = {
"key-mgmt": ("s", "none"),
}
properties["802-11-wireless"]["security"] = ("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

428
panels/network.py
View File

@ -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.conn_status = None
self.reload_timer_id = None
self.monitor_timer_id = None
self.delay_reload_timer_id = None
self.init_status = False
self.reload = False
self.last_ap_bssid = ''
self.network_list = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, hexpand=True, vexpand=True)
self.last_state = None
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'),
'good': self._gtk.PixbufFromIcon('wifi_good'),
'fair': self._gtk.PixbufFromIcon('wifi_fair'),
'weak': self._gtk.PixbufFromIcon('wifi_weak'),
"excellent": self._gtk.PixbufFromIcon(
"wifi_excellent", width=self._gtk.content_width * 0.06, height=self._gtk.content_height * 0.06
),
"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)
self.conn_status = GLib.timeout_add_seconds(1, self.sdbus_nm.monitor_connection_status)
if self.sdbus_nm.nm.wireless_enabled:
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()
scroll.add(self.labels['networkinfo'])
self.labels["networkinfo"] = Gtk.Label()
scroll.add(self.labels["networkinfo"])
self.update_single_network_info()
self.labels['main_box'].pack_start(scroll, True, True, 0)
self.content.add(self.labels['main_box'])
self.labels["main_box"].pack_start(scroll, True, True, 0)
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.content.show_all()
return False
self.connected_ap = self.sdbus_nm.get_connected_ap()
ap_ssid = None
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):
if bssid in self.network_rows:
return
networks = self.sdbus_nm.get_networks()
if networks:
net = next((net for net in networks if bssid == net['BSSID']), None)
if net is None:
self.remove_network_from_list(bssid)
return
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])
for item in self.networks:
ssid = item.get("SSID")
if ssid:
self.add_network_item(
ssid,
item.get("security", "unknown"),
item.get("known", False),
item.get("signal_level", 0),
)
self.network_list.show_all()
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()
identity = self.labels['network_identity'].get_text()
eap_method = self.get_dropdown_value(self.labels['network_eap_method'])
phase2 = self.get_dropdown_value(self.labels['network_phase2'])
psk = self.labels["network_psk"].get_text()
identity = self.labels["network_identity"].get_text()
eap_method = self.get_dropdown_value(self.labels["network_eap_method"])
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()
if showadd and not self.sdbus_nm.is_known(ssid):
sec_type = self.sdbus_nm.get_security_type(ssid)
index = self.get_network_index(ssid)
ssid = self.networks[index]["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()
if self.conn_status is None:
self.delay_reload_networks(1000)
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):
if bssid not in self.network_rows:
logging.error(f"{bssid} not in rows")
return
self.network_list.remove(self.network_rows[bssid])
del self.network_rows[bssid]
del self.networks[bssid]
return
def remove_network_list(self):
for row in self.network_list.get_children():
self.network_list.remove(row)
row.destroy()
self.network_rows.clear()
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)
auth_selection_box.add(self.labels['network_eap_method'])
auth_selection_box.add(self.labels['network_phase2'])
self.labels["network_identity"] = Gtk.Entry(hexpand=True, no_show_all=True)
self.labels["network_identity"].connect("focus-in-event", self._screen.show_keyboard)
self.labels['network_identity'] = Gtk.Entry(hexpand=True, no_show_all=True)
self.labels['network_identity'].connect("focus-in-event", self._screen.show_keyboard)
self.labels["network_psk"] = Gtk.Entry(hexpand=True)
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)
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 = self._gtk.Button("load", style="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):
user_label.show()
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"] = 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(auth_selection_box)
self.labels['add_network'].add(auth_grid)
self.labels["add_network"].add(Gtk.Label(label=_("Connecting to %s") % ssid))
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):
self.labels['networkinfo'].set_markup(
f'<b>{self.interface}</b>\n\n'
+ '<b>' + _("Hostname") + f':</b> {os.uname().nodename}\n'
f'<b>IPv4:</b> {self.sdbus_nm.get_ip_address()}\n'
)
self.labels['networkinfo'].show_all()
return True
def refresh_status(self, state=None):
if state:
self.connected_ap = self.sdbus_nm.get_connected_ap()
if self.connected_ap:
ap_ssid = self.connected_ap.ssid.decode("utf-8")
self.set_connect_state(ap_ssid, state)
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(widget, True)
self._gtk.Button_busy(self.reload_button, True)
if not self.init_status:
self.sdbus_nm.rescan()
else:
self.init_status = False
self.load_networks()
self.activate()
self.reload = True
if self.sdbus_nm.get_is_connected():
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.is_wifi_enabled():
if self.reload_button.get_sensitive():
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)
if self.sdbus_nm.wifi:
if self.sdbus_nm.is_wifi_enabled():
self.delay_reload_networks(1000)
self.start_refresh_timer()
def deactivate(self):
if self.sdbus_nm is None:
return
if self.update_timeout is not None:
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
self.stop_refresh_timer()
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()

4
panels/system.py
View File

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

13
styles/dark/style.css
View File

@ -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;
}

12
styles/light/style.css
View File

@ -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;
}