def on_apply(self): if self.on_query_apply_state() == True: dprint("network apply") m = Mechanism() nap_enable = self.Builder.get_object("nap-enable") if nap_enable.props.active: r_dnsmasq = self.Builder.get_object("r_dnsmasq") if r_dnsmasq.props.active: stype = "DnsMasqHandler" else: stype = "DhcpdHandler" net_ip = self.Builder.get_object("net_ip") net_nat = self.Builder.get_object("net_nat") try: m.EnableNetwork(inet_aton(net_ip.props.text), inet_aton("255.255.255.0"), stype) except Exception as e: d = NetworkErrorDialog(e) d.run() d.destroy() return else: m.DisableNetwork() self.clear_options()
def add_device(self, device, append=True): #device belongs to another adapter if not device['Adapter'] == self.Adapter.get_object_path(): return dprint("adding new device") if append: tree_iter = self.liststore.append() else: tree_iter = self.liststore.prepend() self.set(tree_iter, device=device) self.row_setup_event(tree_iter, device) object_path = device.get_object_path() try: self.set(tree_iter, dbus_path=object_path) except: pass sig = device.connect_signal('property-changed', self._on_device_property_changed) self.__signals[object_path] = sig if device["Connected"]: self.monitor_power_levels(device)
def _on_device_state_changed(self, device, new_state, old_state, reason): new = NM.DeviceState(new_state) old = NM.DeviceState(old_state) state_reason = NM.DeviceStateReason(reason) dprint('New: %s Old: %s Reason: %s' % (new.value_nick, old.value_nick, state_reason.value_nick)) error_msg = None reply_msg = None if new == NM.DeviceState.FAILED: error_msg = 'Connection failed with reason: %s' % state_reason.value_nick elif new == NM.DeviceState.ACTIVATED: reply_msg = 'Connection sucesfully activated' elif (new <= NM.DeviceState.DISCONNECTED or new == NM.DeviceState.DEACTIVATING) and \ (NM.DeviceState.DISCONNECTED < old <= NM.DeviceState.ACTIVATED): error_msg = 'Connection disconnected with reason %s' % state_reason.value_nick else: return # Keep checking the state changes # We are done with state changes device.disconnect_by_func(self._on_device_state_changed) if error_msg is None: self._return_or_reply_handler(reply_msg) else: dprint(error_msg) self._raise_or_error_handler(NMConnectionError(error_msg))
def _on_interfaces_removed(self, object_path, interfaces): if 'org.bluez.Adapter1' in interfaces: dprint(object_path) self.emit('adapter-removed', object_path) elif 'org.bluez.Device1' in interfaces: dprint(object_path) self.emit('device-removed', object_path)
def on_adapter_changed(self, list, adapter_path): dprint("toolbar adapter", adapter_path) if adapter_path == None: self.b_search.props.sensitive = False self.update_send_browse(None) else: self.b_search.props.sensitive = True
def _return_or_reply_handler(self, msg): dprint(msg) if not self.reply_handler: return msg else: self.reply_handler(msg) return
def on_property_changed(self, key, value): dprint("adapter propery changed", key, value) if key == "Discovering": if not value and self.discovering: self.StopDiscovery() self.emit("adapter-property-changed", self.Adapter, (key, value))
def on_property_changed(self, netconf, key, value): dprint(self.ignored_keys) if key in self.ignored_keys: self.ignored_keys.remove(key) return if key == "rb_blueman" or key == "dhcp_client": if value: self.Builder.get_object("rb_blueman").props.active = True else: self.Builder.get_object("rb_nm").props.active = True return if key == "rb_nm": return if key == "gn_enable": self.Builder.get_object(key).props.active = value return if key == "nap_enable": dprint("nap_enable", value) self.Builder.get_object(key).props.active = value nap_frame = self.Builder.get_object("nap_frame") if value: nap_frame.props.sensitive = True else: nap_frame.props.sensitive = False if key == "ip": self.option_changed_notify(key, False) else: self.option_changed_notify(key)
def on_mm_device_added(self, path): dprint(path) props = self.parent.bus.call_blocking( "org.freedesktop.ModemManager", path, "org.freedesktop.DBus.Properties", "GetAll", "s", ["org.freedesktop.ModemManager.Modem"]) if self.rfcomm_dev and props["Driver"] == "bluetooth" and props[ "Device"] in self.rfcomm_dev: dprint("It's our bluetooth modem!") modem = get_icon("modem", 24) blueman = get_icon("blueman", 48) icon = composite_icon(blueman, [(modem, 24, 24, 255)]) Notification( _("Bluetooth Dialup"), _("DUN connection on %s will now be available in Network Manager" ) % self.device.Alias, pixbuf=icon, status_icon=self.parent.Applet.Plugins.StatusIcon) self.reply(self.rfcomm_dev) self.cleanup()
def RequestPinCode(self, device, ok, err): dprint("Agent.RequestPinCode") dialog_msg = _("Enter PIN code for authentication:") notify_msg = _("Enter PIN code") self.ask_passkey(device, dialog_msg, notify_msg, False, False, ok, err) if self.dialog: self.dialog.present_with_time(self.time)
def _on_request_confirmation(self, parameters, invocation): def on_confirm_action(n, action): if action == "confirm": invocation.return_value(GLib.Variant('()', ())) else: invocation.return_dbus_error('org.bluez.Error.Canceled', "User canceled pairing") params = parameters.unpack() if len(params) < 2: device_path = params[0] passkey = None else: device_path, passkey = params dprint("Agent.RequestConfirmation") alias = self.get_device_alias(device_path) notify_message = _("Pairing request for:") + "\n%s" % alias if passkey: notify_message += "\n" + _( "Confirm value for authentication:") + " <b>%s</b>" % passkey actions = [["confirm", _("Confirm")], ["deny", _("Deny")]] self.n = Notification("Bluetooth", notify_message, 0, actions, on_confirm_action, pixbuf=get_icon("blueman", 48), status_icon=self.status_icon)
def on_load(self, applet): self._config = Config("org.blueman.transfer") if not self._config["shared-path"]: d = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DOWNLOAD) if not d: self._config["shared-path"] = os.path.expanduser("~") else: self._config["shared-path"] = d if not os.path.isdir(self._config["shared-path"]): dprint("Configured share directory %s does not exist" % self._config["shared-path"]) dlg = Gtk.MessageDialog(None, buttons=Gtk.ButtonsType.OK, type=Gtk.MessageType.ERROR) text = _("Configured directory for incoming files does not exist") secondary_text = _( 'Please make sure that directory "<b>%s</b>" exists or configure it with blueman-services' ) dlg.props.text = text dlg.format_secondary_markup(secondary_text % self._config["shared-path"]) dlg.run() dlg.destroy() self._manager = obex.Manager() self._manager.connect("transfer-started", self._on_transfer_started) self._manager.connect("transfer-completed", self._on_transfer_completed) self._manager.connect("session-removed", self._on_session_removed) self._watch = dbus.SessionBus().watch_name_owner("org.bluez.obex", self._on_obex_owner_changed)
def RemoveDevice(self, device, iter=None, force=False): dprint(device) if iter == None: iter = self.find_device(device) if not device.Temp and self.compare(self.selected(), iter): self.emit("device-selected", None, None) try: props = device.GetProperties() except: self.device_signals.Disconnect(device.get_object_path()) else: if not "Fake" in props: self.device_signals.Disconnect(device.GetObjectPath()) if device.Temp and not force: dprint("converting to fake") props = copy.deepcopy(props) props["Fake"] = True dev = FakeDevice(props) device = Device(dev) self.device_add_event(device) else: #device.Destroy() self.delete(iter)
def on_adapter_changed(self, lst, adapter_path): dprint("toolbar adapter", adapter_path) if adapter_path is None: self.b_search.props.sensitive = False self.b_send.props.sensitive = False else: self.b_search.props.sensitive = True
def SetAdapter(self, adapter=None): self.clear() if self.discovering: self.emit("adapter-property-changed", self.Adapter, ("Discovering", False)) self.StopDiscovery() if adapter is not None and adapter != "" and not re.match( "hci[0-9]*", adapter): adapter = adapter_path_to_name(adapter) dprint(adapter) try: self.Adapter = self.manager.get_adapter(adapter) self.Adapter.connect_signal('property-changed', self._on_property_changed) self.manager.connect_signal('device-created', self._on_device_created) self.manager.connect_signal('device-removed', self._on_device_removed) self.__adapter_path = self.Adapter.get_object_path() self.emit("adapter-changed", self.__adapter_path) except Bluez.errors.DBusNoSuchAdapterError as e: dprint(e) #try loading default adapter if len(self.manager.list_adapters()) > 0 and adapter is not None: self.SetAdapter() else: self.Adapter = None self.emit("adapter-changed", None)
def add_device(self, device): #device belongs to another adapter if not device['Adapter'] == self.Adapter.get_object_path(): return dprint("adding new device") tree_iter = self.liststore.append() self.set(tree_iter, device=device) self.row_setup_event(tree_iter, device) object_path = device.get_object_path() timestamp = datetime.strftime(datetime.now(), '%Y%m%d%H%M%S%f') try: self.set(tree_iter, dbus_path=object_path, timestamp=float(timestamp)) except: pass sig = device.connect_signal('property-changed', self._on_device_property_changed) self.__signals[object_path] = sig if device["Connected"]: self.monitor_power_levels(device)
def _raise_or_error_handler(self, error): dprint(error) if not self.error_handler: raise error else: self.error_handler(error) return
def on_activate(): dprint("adapter powered", path) if self.Adapter is None: self.SetAdapter(path) self.emit("adapter-added", path)
def on_adapter_changed(self, devlist, adapter_path): dprint("changed") if adapter_path is None: self.update_adapters_list() else: if self.List.Adapter: self.List.DisplayKnownDevices()
def SetAdapter(self, adapter=None): self.clear() if self.discovering: self.emit("adapter-property-changed", self.Adapter, ("Discovering", False)) self.StopDiscovery() if adapter != None and not re.match("hci[0-9]*", adapter): adapter = adapter_path_to_name(adapter) dprint(adapter) if self.Adapter != None: self.adapter_signals.DisconnectAll() try: self.Adapter = self.Manager.GetAdapter(adapter) self.adapter_signals.Handle(self.Adapter, self.on_device_found, "DeviceFound") self.adapter_signals.Handle(self.Adapter, self.on_property_changed, "PropertyChanged") self.adapter_signals.Handle(self.Adapter, self.on_device_created, "DeviceCreated") self.adapter_signals.Handle(self.Adapter, self.on_device_removed, "DeviceRemoved") self.__adapter_path = self.Adapter.GetObjectPath() self.emit("adapter-changed", self.__adapter_path) except Bluez.errors.DBusNoSuchAdapterError, e: dprint(e) #try loading default adapter if len(self.Manager.ListAdapters()) > 0 and adapter != None: self.SetAdapter() else: self.Adapter = None self.emit("adapter-changed", None)
def on_mm_device_added(self, path, name="org.freedesktop.ModemManager"): dprint(path) interface = "%s.Modem" % name props = self.parent.bus.call_blocking(name, path, "org.freedesktop.DBus.Properties", "GetAll", "s", [interface]) try: drivers = props["Drivers"] except KeyError: drivers = [props["Driver"]] if self.rfcomm_dev and "bluetooth" in drivers and props["Device"] in self.rfcomm_dev: dprint("It's our bluetooth modem!") modem = get_icon("modem", 24) blueman = get_icon("blueman", 48) icon = composite_icon(blueman, [(modem, 24, 24, 255)]) Notification(_("Bluetooth Dialup"), _("DUN connection on %s will now be available in Network Manager") % self.service.device.Alias, pixbuf=icon, status_icon=self.parent.Applet.Plugins.StatusIcon) self.reply(self.rfcomm_dev) self.cleanup()
def _on_request_passkey(self, parameters, invocation): dprint("Agent.RequestPasskey") dialog_msg = _("Enter passkey for authentication:") notify_msg = _("Enter passkey") self.ask_passkey(dialog_msg, notify_msg, True, True, parameters, invocation) if self.dialog: self.dialog.present_with_time(self.time_func())
def on_mm_device_added(self, path, name="org.freedesktop.ModemManager"): dprint(path) interface = "%s.Modem" % name props = self.parent.bus.call_blocking( name, path, "org.freedesktop.DBus.Properties", "GetAll", "s", [interface]) try: drivers = props["Drivers"] except KeyError: drivers = [props["Driver"]] if self.rfcomm_dev and "bluetooth" in drivers and props[ "Device"] in self.rfcomm_dev: dprint("It's our bluetooth modem!") modem = get_icon("modem", 24) blueman = get_icon("blueman", 48) icon = composite_icon(blueman, [(modem, 24, 24, 255)]) Notification( _("Bluetooth Dialup"), _("DUN connection on %s will now be available in Network Manager" ) % self.service.device['Alias'], pixbuf=icon, status_icon=self.parent.Applet.Plugins.StatusIcon) self.reply(self.rfcomm_dev) self.cleanup()
def do_apply(self): if not self.netconf.locked("dhcp") or self.netconf.ip4_changed: if self.netconf.ip4_changed: self.do_remove() dhcp_config, existing_subnet = self._read_dhcp_config() subnet = self._generate_subnet_config() # if subnet != self.existing_subnet: f = open(DHCP_CONFIG_FILE, "w") f.write(dhcp_config) f.write(subnet) f.close() cmd = [ have("dhcpd3") or have("dhcpd"), "-pf", "/var/run/dhcpd.pan1.pid", "pan1" ] p = Popen(cmd) ret = p.wait() if ret == 0: dprint("dhcpd started correctly") f = open("/var/run/dhcpd.pan1.pid", "r") self.pid = int(f.read()) f.close() dprint("pid", self.pid) self.netconf.lock("dhcp") else: raise NetworkSetupError( "dhcpd failed to start. Check the system log for errors")
def _on_object_removed(self, object_manager, dbus_object): session_proxy = dbus_object.get_interface('org.bluez.obex.Session1') if session_proxy: session_path = session_proxy.get_object_path() dprint(session_path) self.emit('session-removed', session_path)
def Authorize(self, device, uuid, ok, err): def on_auth_action(n, action): dprint(action) #self.applet.status_icon.set_blinking(False) if action == "always": device = Bluez.Device(n._device) device.set("Trusted", True) if action == "always" or action == "accept": ok() else: err(AgentErrorRejected()) self.n = None dprint("Agent.Authorize") alias = self.get_device_alias(device) uuid16 = uuid128_to_uuid16(uuid) service = uuid16_to_name(uuid16) notify_message = (_("Authorization request for:") + "\n%s\n" + _("Service:") + " <b>%s</b>") % (alias, service) actions = [["always", _("Always accept")], ["accept", _("Accept")], ["deny", _("Deny")]] n = Notification(_("Bluetooth Authentication"), notify_message, 0, actions, on_auth_action, pixbuf=get_icon("blueman", 48), status_icon=self.status_icon) n._device = device
def _on_authorize(self, _agent, transfer_path): transfer = obex.Transfer(transfer_path) session = obex.Session(transfer.session) root = session.root address = session.address filename = transfer.name size = transfer.size try: device = self._applet.Manager.get_adapter().find_device(address) name = device["Alias"] trusted = device["Trusted"] except Exception as e: dprint(e) name = address trusted = False self._pending_transfer = { 'transfer_path': transfer_path, 'address': address, 'root': root, 'filename': filename, 'size': size, 'name': name } try: status_icon = self._applet.Plugins.StatusIcon except: status_icon = None # This device was neither allowed nor is it trusted -> ask for confirmation if address not in self._allowed_devices and not ( self._config['opp-accept'] and trusted): self._notification = Notification( _("Incoming file over Bluetooth"), _("Incoming file %(0)s from %(1)s") % { "0": "<b>" + filename + "</b>", "1": "<b>" + name + "</b>" }, 30000, [["accept", _("Accept"), "help-about"], ["reject", _("Reject"), "help-about"]], self._on_action, pixbuf=get_icon("blueman", 48), status_icon=status_icon) # Device is trusted or was already allowed, larger file -> display a notification, but auto-accept elif size > 350000: self._notification = Notification( _("Receiving file"), _("Receiving file %(0)s from %(1)s") % { "0": "<b>" + filename + "</b>", "1": "<b>" + name + "</b>" }, pixbuf=get_icon("blueman", 48), status_icon=status_icon) self._on_action(self._notification, 'accept') # Device is trusted or was already allowed. very small file -> auto-accept and transfer silently else: self._notification = None self._on_action(self._notification, "accept")
def __init__(self, instance): GObject.GObject.__init__(self) self.Properties = {} self.Temp = False if hasattr(instance, "format") and hasattr(instance, "upper"): self.Device = BluezDevice(instance) else: self.Device = instance #set fallback icon, fixes lp:#327718 self.Device.Icon = "blueman" self.Device.Class = "unknown" self.Valid = True dprint("caching initial properties") self.Properties = self.Device.get_properties() w = weakref.ref(self) self._obj_path = self.Device.get_object_path() self.Device.connect_signal('property-changed', lambda _device, key, value: w() and w().property_changed(key, value)) self._any_adapter = Adapter() self._any_adapter.connect_signal('device-removed', lambda _adapter, path: w() and w().on_device_removed(path))
def io_event(self, source, condition): if condition & GObject.IO_ERR or condition & GObject.IO_HUP: return False data = os.read(self.fd, RFKILL_EVENT_SIZE_V1) if len(data) != RFKILL_EVENT_SIZE_V1: dprint("Bad rfkill event size") else: (idx, type, op, soft, hard) = struct.unpack("IBBBB", data) if op == RFKillOp.ADD: self.switches[idx] = Switch(idx, type, soft, hard) self.emit("switch-added", self.switches[idx]) elif op == RFKillOp.DEL: sw = self.switches[idx] del self.switches[idx] self.emit("switch-removed", sw) elif op == RFKillOp.CHANGE: orig_soft = self.switches[idx].soft orig_hard = self.switches[idx].hard if orig_soft != soft or orig_hard != hard: self.switches[idx].type = type self.switches[idx].soft = soft self.switches[idx].hard = hard self.emit("switch-changed", self.switches[idx]) return True
def RequestPasskey(self, device, ok, err): dprint("Agent.RequestPasskey") dialog_msg = _("Enter passkey for authentication:") notify_msg = _("Enter passkey") self.ask_passkey(device, dialog_msg, notify_msg, True, False, ok, err) if self.dialog: self.dialog.present_with_time(self.time)
def SetAdapter(self, adapter=None): self.clear() if self.discovering: self.emit("adapter-property-changed", self.Adapter, ("Discovering", False)) self.StopDiscovery() if adapter is not None and adapter != "" and not re.match("hci[0-9]*", adapter): adapter = adapter_path_to_name(adapter) dprint(adapter) try: self.Adapter = self.manager.get_adapter(adapter) self.Adapter.connect_signal('property-changed', self._on_property_changed) self.manager.connect_signal('device-created', self._on_device_created) self.manager.connect_signal('device-removed', self._on_device_removed) self.__adapter_path = self.Adapter.get_object_path() self.emit("adapter-changed", self.__adapter_path) except Bluez.errors.DBusNoSuchAdapterError as e: dprint(e) #try loading default adapter if len(self.manager.list_adapters()) > 0 and adapter is not None: self.SetAdapter() else: self.Adapter = None self.emit("adapter-changed", None)
def Authorize(self, device, uuid, ok, err): def on_auth_action(n, action): dprint(action) #self.applet.status_icon.set_blinking(False) if action == "always": device = Bluez.Device(n._device) device.set("Trusted", True) if action == "always" or action == "accept": ok() else: err(AgentErrorRejected()) self.n = None dprint("Agent.Authorize") alias = self.get_device_alias(device) uuid16 = uuid128_to_uuid16(uuid) service = uuid16_to_name(uuid16) notify_message = (_("Authorization request for:") + "\n%s\n" + _("Service:") + " <b>%s</b>") % (alias, service) actions = [["always", _("Always accept"), "blueman-trust"], ["accept", _("Accept"), "help-about"], ["deny", _("Deny"), "help-about"]] n = Notification(_("Bluetooth Authentication"), notify_message, 0, actions, on_auth_action, pixbuf=get_icon("blueman", 48), status_icon=self.status_icon) n._device = device
def RequestPasskey(self, device, ok, err): dprint("Agent.RequestPasskey") dialog_msg = _("Enter passkey for authentication:") notify_msg = _("Enter passkey") self.ask_passkey(device, dialog_msg, notify_msg, True, True, ok, err) if self.dialog: self.dialog.present_with_time(self.time_func())
def _on_authorize_service(self, parameters, invocation): def on_auth_action(n, action): dprint(action) #self.applet.status_icon.set_blinking(False) if action == "always": device = Bluez.Device(n._device) device.set("Trusted", True) if action == "always" or action == "accept": invocation.return_value(GLib.Variant('()', ())) else: invocation.return_dbus_error('org.bluez.Error.Rejected', 'Rejected') self.n = None device, uuid = parameters.unpack() dprint("Agent.Authorize") alias = self.get_device_alias(device) uuid16 = uuid128_to_uuid16(uuid) service = uuid16_to_name(uuid16) notify_message = (_("Authorization request for:") + "\n%s\n" + _("Service:") + " <b>%s</b>") % (alias, service) actions = [["always", _("Always accept")], ["accept", _("Accept")], ["deny", _("Deny")]] n = Notification(_("Bluetooth Authentication"), notify_message, 0, actions, on_auth_action, pixbuf=get_icon("blueman", 48), status_icon=self.status_icon) n._device = device
def do_apply(self): if not self.netconf.locked("dhcp") or self.netconf.ip4_changed: if self.netconf.ip4_changed: self.do_remove() dhcp_config, existing_subnet = self._read_dhcp_config() subnet = self._generate_subnet_config() # if subnet != self.existing_subnet: f = open(DHCP_CONFIG_FILE, "w") f.write(dhcp_config) f.write(subnet) f.close() cmd = [have("dhcpd3") or have("dhcpd"), "-pf", "/var/run/dhcpd-server/dhcp.pan1.pid", "pan1"] p = Popen(cmd) ret = p.wait() if ret == 0: dprint("dhcpd started correctly") f = open("/var/run/dhcp-server/dhcpd.pan1.pid", "r") self.pid = int(f.read()) f.close() dprint("pid", self.pid) self.netconf.lock("dhcp") else: raise Exception("dhcpd failed to start. Check the system log for errors")
def on_apply(self): if self.on_query_apply_state(): dprint("network apply") m = Mechanism() nap_enable = self.Builder.get_object("nap-enable") if nap_enable.props.active: if self.Builder.get_object("r_dhcpd").props.active: stype = "DhcpdHandler" elif self.Builder.get_object("r_dnsmasq").props.active: stype = "DnsMasqHandler" elif self.Builder.get_object("r_udhcpd").props.active: stype = "UdhcpdHandler" net_ip = self.Builder.get_object("net_ip") try: m.EnableNetwork('(ayays)', inet_aton(net_ip.props.text), inet_aton("255.255.255.0"), stype) if not self.Config["nap-enable"]: self.Config["nap-enable"] = True except Exception as e: d = NetworkErrorDialog(e, parent=self.widget.get_toplevel()) d.run() d.destroy() return else: self.Config["nap-enable"] = False m.DisableNetwork() self.clear_options()
def RequestPinCode(self, device, ok, err): dprint("Agent.RequestPinCode") dialog_msg = _("Enter PIN code for authentication:") notify_msg = _("Enter PIN code") self.ask_passkey(device, dialog_msg, notify_msg, False, True, ok, err) if self.dialog: self.dialog.present_with_time(self.time_func())
def __setattr__(self, key, value): if not key in self.__dict__ and "Properties" in self.__dict__ and key in self.__dict__["Properties"]: if not self.Valid: raise Exception("Attempted to set properties for an invalidated device") dprint("Setting property", key, value) self.__dict__["Device"].set(key, value) else: self.__dict__[key] = value
def Cancel(self): dprint("Agent.Cancel") if self.dialog: self.dialog.response(Gtk.ResponseType.REJECT) try: self.n.close() except: pass
def __getattr__(self, name): if name in self.__dict__["Properties"]: if not self.Valid: #traceback.print_stack() dprint("Warning: Attempted to get %s property for an invalidated device" % name) return self.__dict__["Properties"][name] else: return getattr(self.Device, name)
def _on_transfer_completed(self, transfer, success): transfer_path = transfer.get_object_path() signals = self.__transfers.pop(transfer_path) for sig in signals: transfer.disconnect_signal(sig) dprint(transfer_path, success) self.emit('transfer-completed', transfer_path, success)
def on_device_created(self, path): dprint("created", path) iter = self.find_device_by_path(path) if iter == None: dev = Bluez.Device(path) dev = Device(dev) dev.Temp = True self.device_add_event(dev)
def on_adapter_selected(self, cb_adapters): dprint("selected") iter = cb_adapters.get_active_iter() if iter: adapter_path = cb_adapters.get_model().get_value(iter, 1) if self.List.Adapter: if self.List.Adapter.get_object_path() != adapter_path: self.List.SetAdapter(os.path.basename(adapter_path))