def on_request_menu_items(self, manager_menu, device):
audio_source = False
for uuid in device['UUIDs']:
if ServiceUUID(uuid).short_uuid in (AUDIO_SOURCE_SVCLASS_ID, AUDIO_SINK_SVCLASS_ID):
audio_source = True
break
if device['Connected'] and audio_source:
pa = PulseAudioUtils()
if not pa.connected:
self.deferred.append(device)
return
self.item = create_menuitem(_("Audio Profile"), "audio-card")
self.item.props.tooltip_text = _("Select audio profile for PulseAudio")
if not device['Address'] in self.devices:
self.query_pa(device)
else:
self.generate_menu(device)
else:
return
return [(self.item, 300)]
def on_request_menu_items(self, manager_menu: ManagerDeviceMenu, device: Device) -> List[DeviceMenuItem]:
audio_source = False
for uuid in device['UUIDs']:
if ServiceUUID(uuid).short_uuid in (AUDIO_SOURCE_SVCLASS_ID, AUDIO_SINK_SVCLASS_ID):
audio_source = True
break
if device['Connected'] and audio_source:
pa = PulseAudioUtils()
if not pa.connected:
self.deferred.append(device)
return []
item = create_menuitem(_("Audio Profile"), "audio-card")
item.props.tooltip_text = _("Select audio profile for PulseAudio")
if not device['Address'] in self.devices:
self.query_pa(device, item)
else:
self.generate_menu(device, item)
else:
return []
return [DeviceMenuItem(item, DeviceMenuItem.Group.ACTIONS, 300)]
def build_menu(items: Iterable[Mapping[str, Any]],
activate: Callable[..., None]) -> Gtk.Menu:
menu = Gtk.Menu()
for index, item in enumerate(items):
if 'text' in item and 'icon_name' in item:
gtk_item: Gtk.MenuItem = create_menuitem(item['text'],
item['icon_name'])
label = gtk_item.get_child()
assert isinstance(label, Gtk.Label)
if item['markup']:
label.set_markup_with_mnemonic(item['text'])
else:
label.set_text_with_mnemonic(item['text'])
gtk_item.connect(
'activate',
cast(Callable[[Gtk.MenuItem], None],
lambda _, idx=index: activate(idx)))
if 'submenu' in item:
gtk_item.set_submenu(
build_menu(
item['submenu'],
cast(Callable[[int], None],
lambda subid, idx=index: activate(idx, subid))))
if 'tooltip' in item:
gtk_item.props.tooltip_text = item['tooltip']
gtk_item.props.sensitive = item['sensitive']
else:
gtk_item = Gtk.SeparatorMenuItem()
gtk_item.show()
menu.append(gtk_item)
return menu
def add_menu_item(manager_menu, service):
if service.connected:
item = create_menuitem(service.name, get_x_icon(service.icon, 16))
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, get_icon(service.icon, 16))
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if service.group == 'serial':
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.show()
def on_request_menu_items(self, manager_menu: ManagerDeviceMenu, device: Device) -> List[DeviceMenuItem]:
item = create_menuitem(_("_Info"), "dialog-information")
item.props.tooltip_text = _("Show device information")
_window = manager_menu.get_toplevel()
assert isinstance(_window, Gtk.Window)
window = _window # https://github.com/python/mypy/issues/2608
item.connect('activate', lambda x: show_info(device, window))
return [DeviceMenuItem(item, DeviceMenuItem.Group.ACTIONS, 400)]
def on_request_menu_items(
self, manager_menu: ManagerDeviceMenu,
device: Device) -> List[Tuple[Gtk.MenuItem, int]]:
item = create_menuitem(_("Send _note"), "dialog-information")
item.props.tooltip_text = _("Send a text note")
item.connect('activate',
lambda x: send_note(device, manager_menu.get_toplevel()))
return [(item, 500)]
def add_menu_item(manager_menu, service):
if service.connected:
item = create_menuitem(service.name, get_x_icon(service.icon, 16))
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, get_icon(service.icon, 16))
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if service.group == 'serial':
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.show()
def on_load(self, applet):
self.Applet = applet
applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 21)
self.new_dev = create_menuitem(_("_Setup New Device") + "...", get_icon("document-new", 16))
self.new_dev.connect("activate", self.on_setup_new)
self.Applet.Plugins.Menu.Register(self, self.new_dev, 30)
self.Applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 31)
self.send = create_menuitem(_("Send _Files to Device") + "...", get_icon("blueman-send-file", 16))
self.send.connect("activate", self.on_send)
self.Applet.Plugins.Menu.Register(self, self.send, 40)
self.browse = create_menuitem(_("_Browse Files on Device") + "...", get_icon("document-open", 16))
self.browse.connect("activate", self.on_browse)
self.Applet.Plugins.Menu.Register(self, self.browse, 50)
self.Applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 51)
self.devices = create_menuitem(_("_Devices") + "...", get_icon("blueman", 16))
self.devices.connect("activate", self.on_devices)
self.Applet.Plugins.Menu.Register(self, self.devices, 60)
self.adapters = create_menuitem(_("Adap_ters") + "...", get_icon("blueman-device", 16))
self.adapters.connect("activate", self.on_adapters)
self.Applet.Plugins.Menu.Register(self, self.adapters, 70)
self.services = create_menuitem(_("_Local Services") + "...", get_icon("preferences-desktop", 16))
self.services.connect("activate", self.on_local_services)
self.Applet.Plugins.Menu.Register(self, self.services, 80)
self.Applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 81)
about = create_menuitem("_Help", get_icon('help-about', 16))
self.Applet.Plugins.Menu.Register(self, about, 90)
self.plugins = create_menuitem(_("_Plugins"), get_icon("blueman-plugin", 16))
self.plugins.connect("activate", self.on_plugins)
self.Applet.Plugins.Menu.Register(self, self.plugins, 85)
about.connect("activate", self.on_about)
def on_activate(status_icon):
self.on_devices(None)
self.Applet.Plugins.StatusIcon.connect("activate", on_activate)
def on_request_menu_items(
self, manager_menu: ManagerDeviceMenu,
device: Device) -> List[Tuple[Gtk.MenuItem, int]]:
item = create_menuitem(_("Send _note"), "dialog-information")
item.props.tooltip_text = _("Send a text note")
_window = manager_menu.get_toplevel()
assert isinstance(_window, Gtk.Window)
window = _window # https://github.com/python/mypy/issues/2608
item.connect('activate', lambda x: send_note(device, window))
return [(item, 500)]
def add_menu_item(manager_menu, service):
if service.connected:
surface = self._make_x_icon(service.icon, 16)
item = create_menuitem(service.name, surface=surface)
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, service.icon)
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if isinstance(service, SerialService):
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.props.sensitive = service.available
item.show()
def on_load(self, applet):
self.Applet = applet
applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 21)
self.new_dev = create_menuitem(_("_Setup New Device") + "...", get_icon("document-new", 16))
self.new_dev.connect("activate", self.on_setup_new)
self.Applet.Plugins.Menu.Register(self, self.new_dev, 30)
self.Applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 31)
self.send = create_menuitem(_("Send _Files to Device") + "...", get_icon("blueman-send-file", 16))
self.send.connect("activate", self.on_send)
self.Applet.Plugins.Menu.Register(self, self.send, 40)
self.Applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 51)
self.devices = create_menuitem(_("_Devices") + "...", get_icon("blueman", 16))
self.devices.connect("activate", self.on_devices)
self.Applet.Plugins.Menu.Register(self, self.devices, 60)
self.adapters = create_menuitem(_("Adap_ters") + "...", get_icon("blueman-device", 16))
self.adapters.connect("activate", self.on_adapters)
self.Applet.Plugins.Menu.Register(self, self.adapters, 70)
self.services = create_menuitem(_("_Local Services") + "...", get_icon("preferences-desktop", 16))
self.services.connect("activate", self.on_local_services)
self.Applet.Plugins.Menu.Register(self, self.services, 80)
self.Applet.Plugins.Menu.Register(self, Gtk.SeparatorMenuItem(), 81)
about = create_menuitem("_Help", get_icon('help-about', 16))
self.Applet.Plugins.Menu.Register(self, about, 90)
self.plugins = create_menuitem(_("_Plugins"), get_icon("blueman-plugin", 16))
self.plugins.connect("activate", self.on_plugins)
self.Applet.Plugins.Menu.Register(self, self.plugins, 85)
about.connect("activate", self.on_about)
def on_activate(status_icon):
self.on_devices(None)
self.Applet.Plugins.StatusIcon.connect("activate", on_activate)
def on_request_menu_items(self, manager_menu, device):
if self.is_connected(device):
pa = PulseAudioUtils()
if not pa.connected:
self.deferred.append(device)
return
self.item = create_menuitem(_("Audio Profile"), get_icon("audio-card", 16))
self.item.props.tooltip_text = _("Select audio profile for PulseAudio")
if not device.Address in self.devices:
self.query_pa(device)
else:
self.generate_menu(device)
else:
return
return [(self.item, 300)]
def on_request_menu_items(self, manager_menu, device):
if self.is_connected(device):
pa = PulseAudioUtils()
if not pa.connected:
self.deferred.append(device)
return
self.item = create_menuitem(_("Audio Profile"), get_icon("audio-card", 16))
self.item.props.tooltip_text = _("Select audio profile for PulseAudio")
if not device.Address in self.devices:
self.query_pa(device)
else:
self.generate_menu(device)
else:
return
return [(self.item, 300)]
def build_menu(items, activate):
menu = Gtk.Menu()
for index, item in enumerate(items):
if 'text' in item and 'icon_name' in item:
gtk_item = create_menuitem(item['text'], item['icon_name'])
label = gtk_item.get_child()
if item['markup']:
label.set_markup_with_mnemonic(item['text'])
else:
label.set_text_with_mnemonic(item['text'])
gtk_item.connect('activate', lambda _, idx=index: activate(idx))
if 'submenu' in item:
gtk_item.set_submenu(
build_menu(item['submenu'],
lambda subid, idx=index: activate(idx, subid)))
if 'tooltip' in item:
gtk_item.props.tooltip_text = item['tooltip']
gtk_item.props.sensitive = item['sensitive']
else:
gtk_item = Gtk.SeparatorMenuItem()
gtk_item.show()
menu.append(gtk_item)
return menu
def on_request_menu_items(self, manager_menu, device):
item = create_menuitem(_("Send _note"), "dialog-information")
item.props.tooltip_text = _("Send a text note")
item.connect('activate', lambda x: send_note(device, manager_menu.get_toplevel()))
return [(item, 500)]
def on_load(self, applet):
item = create_menuitem("_Exit", get_icon("application-exit", 16))
item.connect("activate", lambda x: Gtk.main_quit())
applet.Plugins.Menu.Register(self, item, 100)
def generate(self) -> None:
self.clear()
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "paired", "connected", "trusted", "objpush", "device",
"blocked")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
assert path[0] is not None
row = self.Blueman.List.get(path[0], "alias", "paired", "connected", "trusted", "objpush", "device",
"blocked")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item: Gtk.MenuItem = create_menuitem(op, "network-transmit-receive-symbolic")
item.props.sensitive = False
item.show()
self.append(item)
return
show_generic_connect = self.show_generic_connect_calc(self.SelectedDevice['UUIDs'])
if not row["connected"] and show_generic_connect:
connect_item = create_menuitem(_("<b>_Connect</b>"), "bluetooth-symbolic")
connect_item.connect("activate", lambda _item: self.connect_service(self.SelectedDevice))
connect_item.props.tooltip_text = _("Connects auto connect profiles A2DP source, A2DP sink, and HID")
connect_item.show()
self.append(connect_item)
elif show_generic_connect:
connect_item = create_menuitem(_("<b>_Disconnect</b>"), "bluetooth-disabled-symbolic")
connect_item.props.tooltip_text = _("Forcefully disconnect the device")
connect_item.connect("activate", lambda _item: self.disconnect_service(self.SelectedDevice))
connect_item.show()
self.append(connect_item)
logging.debug(row["alias"])
items = [item for plugin in self.Blueman.Plugins.get_loaded_plugins(MenuItemsProvider)
for item in plugin.on_request_menu_items(self, self.SelectedDevice)]
connect_items = [i for i in items if i.group == DeviceMenuItem.Group.CONNECT]
disconnect_items = [i for i in items if i.group == DeviceMenuItem.Group.DISCONNECT]
autoconnect_items = [item for item in items if item.group == DeviceMenuItem.Group.AUTOCONNECT]
action_items = [i for i in items if i.group == DeviceMenuItem.Group.ACTIONS]
if connect_items:
self.append(self._create_header(_("<b>Connect To:</b>")))
for it in sorted(connect_items, key=lambda i: i.position):
self.append(it.item)
if disconnect_items:
self.append(self._create_header(_("<b>Disconnect:</b>")))
for it in sorted(disconnect_items, key=lambda i: i.position):
self.append(it.item)
config = AutoConnectConfig()
generic_service = ServiceUUID("00000000-0000-0000-0000-000000000000")
generic_autoconnect = (self.SelectedDevice.get_object_path(), str(generic_service)) in set(config["services"])
if row["connected"] or generic_autoconnect or autoconnect_items:
self.append(self._create_header(_("<b>Auto-connect:</b>")))
if row["connected"] or generic_autoconnect:
item = Gtk.CheckMenuItem(label=generic_service.name)
config.bind_to_menuitem(item, self.SelectedDevice, str(generic_service))
item.show()
self.append(item)
for it in sorted(autoconnect_items, key=lambda i: i.position):
self.append(it.item)
if show_generic_connect or connect_items or disconnect_items or autoconnect_items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
for it in sorted(action_items, key=lambda i: i.position):
self.append(it.item)
send_item = create_menuitem(_("Send a _File…"), "blueman-send-symbolic")
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate", lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), "blueman-pair-symbolic")
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["paired"]:
item.connect("activate", lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), "blueman-trust-symbolic")
item.connect("activate", lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"), "blueman-untrust-symbolic")
self.append(item)
item.connect("activate", lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
if not row["blocked"]:
item = create_menuitem(_("_Block"), "blueman-block-symbolic")
item.connect("activate", lambda x: self.Blueman.toggle_blocked(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Unblock"), "blueman-block-symbolic")
self.append(item)
item.connect("activate", lambda x: self.Blueman.toggle_blocked(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Block/Unblock this device")
def on_rename(_item: Gtk.MenuItem, device: Device) -> None:
def on_response(dialog: Gtk.Dialog, response_id: int) -> None:
if response_id == Gtk.ResponseType.ACCEPT:
assert isinstance(alias_entry, Gtk.Entry) # https://github.com/python/mypy/issues/2608
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Builder("rename-device.ui")
dialog = builder.get_widget("dialog", Gtk.Dialog)
dialog.set_transient_for(self.Blueman.window)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_widget("alias_entry", Gtk.Entry)
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_mnemonic(_("R_ename device…"))
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove…"), "list-remove-symbolic")
item.connect("activate", lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _("Remove this device from the known devices list")
def on_request_menu_items(self, manager_menu, device):
item = create_menuitem(_("Send _note"), get_icon("info", 16))
item.props.tooltip_text = _("Send a text note")
item.connect('activate', lambda x: send_note(device, manager_menu.get_toplevel()))
return [(item, 500)]
def generate(self):
self.clear()
items: List[Tuple[int, Gtk.MenuItem]] = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "paired",
"connected", "trusted", "objpush",
"device")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
row = self.Blueman.List.get(path[0], "alias", "paired",
"connected", "trusted", "objpush",
"device")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item = create_menuitem(op, "network-transmit-receive")
item.props.sensitive = False
item.show()
self.append(item)
return
show_generic_connect = self.show_generic_connect_calc(
self.SelectedDevice['UUIDs'])
if not row["connected"] and show_generic_connect:
connect_item = create_menuitem(_("_<b>Connect</b>"), "blueman")
connect_item.connect("activate", self.generic_connect,
self.SelectedDevice, True)
connect_item.props.tooltip_text = _(
"Connects auto connect profiles A2DP source, A2DP sink, and HID"
)
connect_item.show()
self.append(connect_item)
elif show_generic_connect:
connect_item = create_menuitem(_("_<b>Disconnect</b>"),
"network-offline")
connect_item.props.tooltip_text = _(
"Forcefully disconnect the device")
connect_item.connect("activate", self.generic_connect,
self.SelectedDevice, False)
connect_item.show()
self.append(connect_item)
rets = self.Blueman.Plugins.run("on_request_menu_items", self,
self.SelectedDevice)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
logging.debug(row["alias"])
have_disconnectables = False
have_connectables = False
if True in map(lambda x: 100 <= x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200,
items) and (have_connectables or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File…"), "edit-copy")
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate",
lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), "dialog-password")
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["paired"]:
item.connect("activate",
lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), "blueman-trust")
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"), "blueman-untrust")
self.append(item)
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Set up…"), "document-properties")
self.append(item)
item.connect("activate",
lambda x: self.Blueman.setup(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman.window)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_mnemonic(_("R_ename device…"))
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove…"), "edit-delete")
item.connect("activate",
lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _(
"Remove this device from the known devices list")
def on_request_menu_items(self, manager_menu, device):
items = []
appl = AppletService()
self.has_dun = False
serial_items = []
def add_menu_item(manager_menu, service):
if service.connected:
item = create_menuitem(service.name, get_x_icon(service.icon, 16))
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, get_icon(service.icon, 16))
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if service.group == 'serial':
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.show()
for service in get_services(device):
try:
add_menu_item(manager_menu, service)
except Exception as e:
dprint("Failed to load service %s" % service.name)
traceback.print_exc()
continue
if service.group == 'serial':
for dev in rfcomm_list():
if dev["dst"] == device['Address'] and dev["state"] == "connected":
devname = _("Serial Port %s") % "rfcomm%d" % dev["id"]
item = create_menuitem(devname, get_x_icon("modem", 16))
item.connect("activate", manager_menu.on_disconnect, service, dev["id"])
items.append((item, 120))
item.show()
if service.group == 'network' and service.connected:
if "DhcpClient" in appl.QueryPlugins():
def renew(x):
appl.DhcpClient('(s)', Network(device.get_object_path()).get_properties()["Interface"])
item = create_menuitem(_("Renew IP Address"), get_icon("view-refresh", 16))
item.connect("activate", renew)
item.show()
items.append((item, 201))
if self.has_dun and "PPPSupport" in appl.QueryPlugins():
def open_settings(i, device):
from blueman.gui.GsmSettings import GsmSettings
d = GsmSettings(device['Address'])
d.run()
d.destroy()
item = Gtk.SeparatorMenuItem()
item.show()
serial_items.append(item)
item = create_menuitem(_("Dialup Settings"), get_icon("gtk-preferences", 16))
serial_items.append(item)
item.show()
item.connect("activate", open_settings, device)
if len(serial_items) > 1:
sub = Gtk.Menu()
sub.show()
item = create_menuitem(_("Serial Ports"), get_icon("modem", 16))
item.set_submenu(sub)
item.show()
items.append((item, 90))
for item in serial_items:
sub.append(item)
else:
for item in serial_items:
items.append((item, 80))
return items
def on_request_menu_items(
self, manager_menu: ManagerDeviceMenu,
device: Device) -> List[Tuple[Gtk.MenuItem, int]]:
items: List[Tuple[Gtk.MenuItem, int]] = []
appl = AppletService()
self.has_dun = False
serial_items: List[Gtk.MenuItem] = []
def add_menu_item(manager_menu: ManagerDeviceMenu,
service: Service) -> None:
if service.connected:
surface = self._make_x_icon(service.icon, 16)
item = create_menuitem(service.name, surface=surface)
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, service.icon)
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if isinstance(service, SerialService):
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.props.sensitive = service.available
item.show()
for service in get_services(device):
add_menu_item(manager_menu, service)
if isinstance(service, SerialService):
for dev in rfcomm_list():
if dev["dst"] == device['Address'] and dev[
"state"] == "connected":
devname = _("Serial Port %s") % "rfcomm%d" % dev["id"]
surface = self._make_x_icon("modem", 16)
item: Gtk.MenuItem = create_menuitem(devname,
surface=surface)
item.connect("activate", manager_menu.on_disconnect,
service, dev["id"])
items.append((item, 120))
item.show()
if isinstance(service, NetworkService) and service.connected:
if "DhcpClient" in appl.QueryPlugins():
def renew(_item: Gtk.MenuItem) -> None:
appl.DhcpClient('(s)', device.get_object_path())
item = create_menuitem(_("Renew IP Address"),
"view-refresh")
item.connect("activate", renew)
item.show()
items.append((item, 201))
if self.has_dun and ('PPPSupport' in appl.QueryPlugins()
or 'NMDUNSupport' in appl.QueryPlugins()):
def open_settings(_item: Gtk.MenuItem, device: Device) -> None:
from blueman.gui.GsmSettings import GsmSettings
d = GsmSettings(device['Address'])
d.run()
d.destroy()
item = Gtk.SeparatorMenuItem()
item.show()
serial_items.append(item)
item = create_menuitem(_("Dialup Settings"), "preferences-other")
serial_items.append(item)
item.show()
item.connect("activate", open_settings, device)
if len(serial_items) > 1:
sub = Gtk.Menu()
sub.show()
item = create_menuitem(_("Serial Ports"), "modem")
item.set_submenu(sub)
item.show()
items.append((item, 90))
for item in serial_items:
sub.append(item)
else:
for item in serial_items:
items.append((item, 80))
return items
def on_request_menu_items(self, manager_menu, device):
item = create_menuitem(_("Info"), get_icon("info", 16))
item.props.tooltip_text = _("Show device information")
item.connect('activate', lambda x: show_info(device, manager_menu.get_toplevel()))
return [(item, 400)]
def on_request_menu_items(self, manager_menu, device):
items = []
appl = AppletService()
self.has_dun = False
serial_items = []
def add_menu_item(manager_menu, service):
if service.connected:
item = create_menuitem(service.name, get_x_icon(service.icon, 16))
item.connect("activate", manager_menu.on_disconnect, service)
items.append((item, service.priority + 100))
else:
item = create_menuitem(service.name, get_icon(service.icon, 16))
if service.description:
item.props.tooltip_text = service.description
item.connect("activate", manager_menu.on_connect, service)
if service.group == 'serial':
serial_items.append(item)
if isinstance(service, DialupNetwork):
self.has_dun = True
else:
items.append((item, service.priority))
item.show()
for service in device.get_services():
try:
add_menu_item(manager_menu, service)
except Exception as e:
dprint("Failed to load service %s" % service.name)
traceback.print_exc()
continue
if service.group == 'serial':
for dev in rfcomm_list():
if dev["dst"] == device.Address and dev["state"] == "connected":
devname = _("Serial Port %s") % "rfcomm%d" % dev["id"]
item = create_menuitem(devname, get_x_icon("modem", 16))
item.connect("activate", manager_menu.on_disconnect, service, dev["id"])
items.append((item, 120))
item.show()
if service.group == 'network' and service.connected:
if "DhcpClient" in appl.QueryPlugins():
def renew(x):
appl.DhcpClient(Network(device.get_object_path()).get_properties()["Interface"])
item = create_menuitem(_("Renew IP Address"), get_icon("view-refresh", 16))
item.connect("activate", renew)
item.show()
items.append((item, 201))
if self.has_dun and "PPPSupport" in appl.QueryPlugins():
def open_settings(i, device):
from blueman.gui.GsmSettings import GsmSettings
d = GsmSettings(device.Address)
d.run()
d.destroy()
item = Gtk.SeparatorMenuItem()
item.show()
serial_items.append(item)
item = create_menuitem(_("Dialup Settings"), get_icon("gtk-preferences", 16))
serial_items.append(item)
item.show()
item.connect("activate", open_settings, device)
if len(serial_items) > 1:
sub = Gtk.Menu()
sub.show()
item = create_menuitem(_("Serial Ports"), get_icon("modem", 16))
item.set_submenu(sub)
item.show()
items.append((item, 90))
for item in serial_items:
sub.append(item)
else:
for item in serial_items:
items.append((item, 80))
return items
def on_request_menu_items(self, manager_menu, device):
item = create_menuitem(_("_Info"), "dialog-information")
item.props.tooltip_text = _("Show device information")
item.connect('activate',
lambda x: show_info(device, manager_menu.get_toplevel()))
return [(item, 400)]
def on_request_menu_items(self, manager_menu: ManagerDeviceMenu,
device: Device) -> List[DeviceMenuItem]:
items: List[DeviceMenuItem] = []
appl = AppletService()
services = get_services(device)
connectable_services = [
service for service in services if service.connectable
]
for service in connectable_services:
item: Gtk.MenuItem = create_menuitem(service.name, service.icon)
if service.description:
item.props.tooltip_text = service.description
item.connect(
"activate", lambda _item: manager_menu.connect_service(
service.device, service.uuid))
items.append(
DeviceMenuItem(item, DeviceMenuItem.Group.CONNECT,
service.priority))
item.props.sensitive = service.available
item.show()
connected_services = [
service for service in services if service.connected_instances
]
for service in connected_services:
for instance in service.connected_instances:
surface = self._make_x_icon(service.icon, 16)
item = create_menuitem(instance.name, surface=surface)
item.connect(
"activate", lambda _item: manager_menu.disconnect_service(
service.device, service.uuid, instance.port))
items.append(
DeviceMenuItem(item, DeviceMenuItem.Group.DISCONNECT,
service.priority + 100))
item.show()
if services:
config = AutoConnectConfig()
autoconnect_services = set(config["services"])
for service in services:
if service.connected_instances or (
device.get_object_path(),
service.uuid) in autoconnect_services:
item = Gtk.CheckMenuItem(label=service.name)
config.bind_to_menuitem(item, device, service.uuid)
item.show()
items.append(
DeviceMenuItem(item, DeviceMenuItem.Group.AUTOCONNECT,
service.priority))
for action, priority in set((action, service.priority)
for service in services
for action in service.common_actions
if any(plugin in appl.QueryPlugins()
for plugin in action.plugins)):
item = create_menuitem(action.title, action.icon)
items.append(
DeviceMenuItem(item, DeviceMenuItem.Group.ACTIONS,
priority + 200))
item.show()
item.connect("activate",
self._get_activation_handler(action.callback))
return items
def __init__(self, blueman):
self.blueman = blueman
self.Config = Config("org.blueman.general")
self.adapter_items: Dict[str, Tuple[Gtk.RadioMenuItem, Adapter]] = {}
self._adapters_group: List[Gtk.RadioMenuItem] = []
self._insert_adapter_item_pos = 2
self.Search = None
self.item_adapter = self.blueman.Builder.get_object("item_adapter")
self.item_device = self.blueman.Builder.get_object("item_device")
self.item_view = self.blueman.Builder.get_object("item_view")
self.item_help = self.blueman.Builder.get_object("item_help")
help_menu = Gtk.Menu()
self.item_help.set_submenu(help_menu)
help_menu.show()
report_item = create_menuitem(_("_Report a Problem"), "dialog-warning")
report_item.show()
help_menu.append(report_item)
report_item.connect("activate",
lambda x: launch(f"xdg-open {WEBSITE}/issues"))
sep = Gtk.SeparatorMenuItem()
sep.show()
help_menu.append(sep)
help_item = create_menuitem(_("_Help"), "help-about")
help_item.show()
help_menu.append(help_item)
help_item.connect(
"activate",
lambda x: show_about_dialog('Blueman ' + _('Device Manager'),
parent=self.blueman.get_toplevel()))
view_menu = Gtk.Menu()
self.item_view.set_submenu(view_menu)
view_menu.show()
item_toolbar = Gtk.CheckMenuItem.new_with_mnemonic(_("Show _Toolbar"))
item_toolbar.show()
view_menu.append(item_toolbar)
self.blueman.Config.bind_to_widget("show-toolbar", item_toolbar,
"active")
item_statusbar = Gtk.CheckMenuItem.new_with_mnemonic(
_("Show _Statusbar"))
item_statusbar.show()
view_menu.append(item_statusbar)
self.blueman.Config.bind_to_widget("show-statusbar", item_statusbar,
"active")
item_services = Gtk.SeparatorMenuItem()
view_menu.append(item_services)
item_services.show()
sorting_group: List[Gtk.RadioMenuItem] = []
item_sort = Gtk.MenuItem.new_with_mnemonic(_("S_ort By"))
view_menu.append(item_sort)
item_sort.show()
sorting_menu = Gtk.Menu()
item_sort.set_submenu(sorting_menu)
self._sort_alias_item = Gtk.RadioMenuItem.new_with_mnemonic(
sorting_group, _("_Name"))
self._sort_alias_item.show()
sorting_group = self._sort_alias_item.get_group()
sorting_menu.append(self._sort_alias_item)
self._sort_timestamp_item = Gtk.RadioMenuItem.new_with_mnemonic(
sorting_group, _("_Added"))
self._sort_timestamp_item.show()
sorting_menu.append(self._sort_timestamp_item)
sort_config = self.Config['sort-by']
if sort_config == "alias":
self._sort_alias_item.props.active = True
else:
self._sort_timestamp_item.props.active = True
sort_sep = Gtk.SeparatorMenuItem()
sort_sep.show()
sorting_menu.append(sort_sep)
self._sort_type_item = Gtk.CheckMenuItem.new_with_mnemonic(
_("_Descending"))
self._sort_type_item.show()
sorting_menu.append(self._sort_type_item)
if self.Config['sort-order'] == "ascending":
self._sort_type_item.props.active = False
else:
self._sort_type_item.props.active = True
sep = Gtk.SeparatorMenuItem()
sep.show()
view_menu.append(sep)
item_plugins = create_menuitem(_("_Plugins"), 'blueman-plugin')
item_plugins.show()
view_menu.append(item_plugins)
item_plugins.connect('activate', self._on_plugin_dialog_activate)
item_services = create_menuitem(
_("_Local Services") + "…", "preferences-desktop")
item_services.connect(
'activate', lambda *args: launch("blueman-services",
name=_("Service Preferences")))
view_menu.append(item_services)
item_services.show()
adapter_menu = Gtk.Menu()
self.item_adapter.set_submenu(adapter_menu)
self.item_adapter.props.sensitive = False
search_item = create_menuitem(_("_Search"), "edit-find")
search_item.connect("activate", lambda x: self.blueman.inquiry())
search_item.show()
adapter_menu.prepend(search_item)
self.Search = search_item
sep = Gtk.SeparatorMenuItem()
sep.show()
adapter_menu.append(sep)
sep = Gtk.SeparatorMenuItem()
sep.show()
adapter_menu.append(sep)
adapter_settings = create_menuitem(_("_Preferences"),
"preferences-system")
adapter_settings.connect("activate",
lambda x: self.blueman.adapter_properties())
adapter_settings.show()
adapter_menu.append(adapter_settings)
sep = Gtk.SeparatorMenuItem()
sep.show()
adapter_menu.append(sep)
exit_item = create_menuitem(_("_Exit"), "application-exit")
exit_item.connect("activate", lambda x: Gtk.main_quit())
exit_item.show()
adapter_menu.append(exit_item)
self.item_adapter.show()
self.item_view.show()
self.item_help.show()
self.item_device.show()
self.item_device.props.sensitive = False
self._manager = Manager()
self._manager.connect_signal("adapter-added", self.on_adapter_added)
self._manager.connect_signal("adapter-removed",
self.on_adapter_removed)
blueman.List.connect("device-selected", self.on_device_selected)
for adapter in self._manager.get_adapters():
self.on_adapter_added(None, adapter.get_object_path())
self.device_menu = None
self.Config.connect("changed", self._on_settings_changed)
self._sort_alias_item.connect("activate", self._on_sorting_changed,
"alias")
self._sort_timestamp_item.connect("activate", self._on_sorting_changed,
"timestamp")
self._sort_type_item.connect("activate", self._on_sorting_changed,
"sort-type")
def __init__(self, blueman):
self.blueman = blueman
self.Config = Config("org.blueman.general")
self.adapter_items = {}
self._adapters_group = []
self._insert_adapter_item_pos = 2
self.Search = None
self.item_adapter = self.blueman.Builder.get_object("item_adapter")
self.item_device = self.blueman.Builder.get_object("item_device")
self.item_view = self.blueman.Builder.get_object("item_view")
self.item_help = self.blueman.Builder.get_object("item_help")
help_menu = Gtk.Menu()
self.item_help.set_submenu(help_menu)
help_menu.show()
report_item = create_menuitem(_("_Report a Problem"), "dialog-warning")
report_item.show()
help_menu.append(report_item)
report_item.connect("activate", lambda x: launch("xdg-open %s/issues" % WEBSITE, None, True))
sep = Gtk.SeparatorMenuItem()
sep.show()
help_menu.append(sep)
help_item = create_menuitem("_Help", "help-about")
help_item.show()
help_menu.append(help_item)
help_item.connect("activate", lambda x: show_about_dialog('Blueman ' + _('Device Manager'),
parent=self.blueman.get_toplevel()))
view_menu = Gtk.Menu()
self.item_view.set_submenu(view_menu)
view_menu.show()
item_toolbar = Gtk.CheckMenuItem.new_with_mnemonic(_("Show _Toolbar"))
item_toolbar.show()
view_menu.append(item_toolbar)
self.blueman.Config.bind_to_widget("show-toolbar", item_toolbar, "active")
item_statusbar = Gtk.CheckMenuItem.new_with_mnemonic(_("Show _Statusbar"))
item_statusbar.show()
view_menu.append(item_statusbar)
self.blueman.Config.bind_to_widget("show-statusbar", item_statusbar, "active")
item_services = Gtk.SeparatorMenuItem()
view_menu.append(item_services)
item_services.show()
sorting_group = []
item_sort = Gtk.MenuItem.new_with_mnemonic(_("S_ort By"))
view_menu.append(item_sort)
item_sort.show()
sorting_menu = Gtk.Menu()
item_sort.set_submenu(sorting_menu)
self._sort_alias_item = Gtk.RadioMenuItem.new_with_mnemonic(sorting_group, _("_Name"))
self._sort_alias_item.show()
sorting_group = self._sort_alias_item.get_group()
sorting_menu.append(self._sort_alias_item)
self._sort_timestamp_item = Gtk.RadioMenuItem.new_with_mnemonic(sorting_group, _("_Added"))
self._sort_timestamp_item.show()
sorting_menu.append(self._sort_timestamp_item)
sort_config = self.Config['sort-by']
if sort_config == "alias":
self._sort_alias_item.props.active = True
else:
self._sort_timestamp_item.props.active = True
sort_sep = Gtk.SeparatorMenuItem()
sort_sep.show()
sorting_menu.append(sort_sep)
self._sort_type_item = Gtk.CheckMenuItem.new_with_mnemonic(_("_Descending"))
self._sort_type_item.show()
sorting_menu.append(self._sort_type_item)
if self.Config['sort-order'] == "ascending":
self._sort_type_item.props.active = False
else:
self._sort_type_item.props.active = True
sep = Gtk.SeparatorMenuItem()
sep.show()
view_menu.append(sep)
item_plugins = create_menuitem(_("_Plugins"), 'blueman-plugin')
item_plugins.show()
view_menu.append(item_plugins)
item_plugins.connect('activate', self._on_plugin_dialog_activate)
item_services = create_menuitem(_("_Local Services") + "...", "preferences-desktop")
item_services.connect('activate', lambda *args: launch("blueman-services", None, False, "blueman",
_("Service Preferences")))
view_menu.append(item_services)
item_services.show()
adapter_menu = Gtk.Menu()
self.item_adapter.set_submenu(adapter_menu)
self.item_adapter.props.sensitive = False
search_item = create_menuitem(_("_Search"), "edit-find")
search_item.connect("activate", lambda x: self.blueman.inquiry())
search_item.show()
adapter_menu.prepend(search_item)
self.Search = search_item
sep = Gtk.SeparatorMenuItem()
sep.show()
adapter_menu.append(sep)
sep = Gtk.SeparatorMenuItem()
sep.show()
adapter_menu.append(sep)
adapter_settings = create_menuitem("_Preferences", "preferences-system")
adapter_settings.connect("activate", lambda x: self.blueman.adapter_properties())
adapter_settings.show()
adapter_menu.append(adapter_settings)
sep = Gtk.SeparatorMenuItem()
sep.show()
adapter_menu.append(sep)
exit_item = create_menuitem("_Exit", "application-exit")
exit_item.connect("activate", lambda x: Gtk.main_quit())
exit_item.show()
adapter_menu.append(exit_item)
self.item_adapter.show()
self.item_view.show()
self.item_help.show()
self.item_device.show()
self.item_device.props.sensitive = False
self._manager = bluez.Manager()
self._manager.connect_signal("adapter-added", self.on_adapter_added)
self._manager.connect_signal("adapter-removed", self.on_adapter_removed)
blueman.List.connect("device-selected", self.on_device_selected)
for adapter in self._manager.get_adapters():
self.on_adapter_added(None, adapter.get_object_path())
self.device_menu = None
self.Config.connect("changed", self._on_settings_changed)
self._sort_alias_item.connect("activate", self._on_sorting_changed, "alias")
self._sort_timestamp_item.connect("activate", self._on_sorting_changed, "timestamp")
self._sort_type_item.connect("activate", self._on_sorting_changed, "sort-type")
def generate(self):
self.clear()
items = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "paired",
"connected", "trusted", "objpush",
"device")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
row = self.Blueman.List.get(path[0], "alias", "paired",
"connected", "trusted", "objpush",
"device")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item = create_menuitem(op, "network-transmit-recieve")
item.props.sensitive = False
item.show()
self.append(item)
return
# Generic (dis)connect
# LE devices do not appear to expose certain properties like uuids until connect to at least once.
# show generic connect for these as we will not show any way to connect otherwise.
device_uuids = self.SelectedDevice['UUIDs']
show_generic_connect = not device_uuids
for uuid in device_uuids:
service_uuid = ServiceUUID(uuid)
if service_uuid.short_uuid in (AUDIO_SOURCE_SVCLASS_ID,
AUDIO_SINK_SVCLASS_ID,
HANDSFREE_AGW_SVCLASS_ID,
HANDSFREE_SVCLASS_ID,
HEADSET_SVCLASS_ID, HID_SVCLASS_ID,
0x1812):
show_generic_connect = True
break
elif not service_uuid.reserved:
if uuid == '03b80e5a-ede8-4b33-a751-6ce34ec4c700':
show_generic_connect = True
break
if not row["connected"] and show_generic_connect:
connect_item = create_menuitem(_("_Connect"), "blueman")
connect_item.connect("activate", self._generic_connect,
self.SelectedDevice, True)
connect_item.props.tooltip_text = _(
"Connects auto connect profiles A2DP source, A2DP sink, and HID"
)
connect_item.show()
self.append(connect_item)
elif show_generic_connect:
connect_item = create_menuitem(_("_Disconnect"), "network-offline")
connect_item.props.tooltip_text = _(
"Forcefully disconnect the device")
connect_item.connect("activate", self._generic_connect,
self.SelectedDevice, False)
connect_item.show()
self.append(connect_item)
rets = self.Blueman.Plugins.run("on_request_menu_items", self,
self.SelectedDevice)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
logging.debug(row["alias"])
have_disconnectables = False
have_connectables = False
if True in map(lambda x: 100 <= x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200,
items) and (have_connectables or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."), "edit-copy")
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate",
lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), "dialog-password")
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["paired"]:
item.connect("activate",
lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), "blueman-trust")
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"), "blueman-untrust")
self.append(item)
item.connect(
"activate",
lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."), "document-properties")
self.append(item)
item.connect("activate",
lambda x: self.Blueman.setup(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_mnemonic("R_ename device...")
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."), "edit-delete")
item.connect("activate",
lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _(
"Remove this device from the known devices list")
def Generate(self):
self.clear()
items = []
if not self.is_popup or self.props.visible:
selected = self.Blueman.List.selected()
if not selected:
return
row = self.Blueman.List.get(selected, "alias", "paired", "connected", "trusted", "objpush", "device")
else:
(x, y) = self.Blueman.List.get_pointer()
path = self.Blueman.List.get_path_at_pos(x, y)
if path is not None:
row = self.Blueman.List.get(path[0], "alias", "paired", "connected", "trusted", "objpush", "device")
else:
return
self.SelectedDevice = row["device"]
op = self.get_op(self.SelectedDevice)
if op is not None:
item = create_menuitem(op, "network-transmit-recieve")
item.props.sensitive = False
item.show()
self.append(item)
return
# Generic (dis)connect
# LE devices do not appear to expose certain properties like uuids until connect to at least once.
# show generic connect for these as we will not show any way to connect otherwise.
device_uuids = self.SelectedDevice['UUIDs']
show_generic_connect = not device_uuids
for uuid in device_uuids:
service_uuid = ServiceUUID(uuid)
if service_uuid.short_uuid in (
AUDIO_SOURCE_SVCLASS_ID, AUDIO_SINK_SVCLASS_ID, HANDSFREE_AGW_SVCLASS_ID, HANDSFREE_SVCLASS_ID,
HEADSET_SVCLASS_ID, HID_SVCLASS_ID, 0x1812
):
show_generic_connect = True
break
elif not service_uuid.reserved:
show_generic_connect = uuid == '03b80e5a-ede8-4b33-a751-6ce34ec4c700'
break
if not row["connected"] and show_generic_connect:
connect_item = create_menuitem(_("_Connect"), "blueman")
connect_item.connect("activate", self._generic_connect, self.SelectedDevice, True)
connect_item.props.tooltip_text = _("Connects auto connect profiles A2DP source, A2DP sink, and HID")
connect_item.show()
self.append(connect_item)
elif show_generic_connect:
connect_item = create_menuitem(_("_Disconnect"), "network-offline")
connect_item.props.tooltip_text = _("Forcefully disconnect the device")
connect_item.connect("activate", self._generic_connect, self.SelectedDevice, False)
connect_item.show()
self.append(connect_item)
rets = self.Blueman.Plugins.Run("on_request_menu_items", self, self.SelectedDevice)
for ret in rets:
if ret:
for (item, pos) in ret:
items.append((pos, item))
logging.debug(row["alias"])
have_disconnectables = False
have_connectables = False
if True in map(lambda x: 100 <= x[0] < 200, items):
have_disconnectables = True
if True in map(lambda x: x[0] < 100, items):
have_connectables = True
if True in map(lambda x: x[0] >= 200, items) and (have_connectables or have_disconnectables):
item = Gtk.SeparatorMenuItem()
item.show()
items.append((199, item))
if have_connectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Connect To:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((0, item))
if have_disconnectables:
item = Gtk.MenuItem()
label = Gtk.Label()
label.set_markup(_("<b>Disconnect:</b>"))
label.props.xalign = 0.0
label.show()
item.add(label)
item.props.sensitive = False
item.show()
items.append((99, item))
items.sort(key=itemgetter(0))
for priority, item in items:
self.append(item)
if items:
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
del items
send_item = create_menuitem(_("Send a _File..."), "edit-copy")
send_item.props.sensitive = False
self.append(send_item)
send_item.show()
if row["objpush"]:
send_item.connect("activate", lambda x: self.Blueman.send(self.SelectedDevice))
send_item.props.sensitive = True
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Pair"), "dialog-password")
item.props.tooltip_text = _("Create pairing with the device")
self.append(item)
item.show()
if not row["paired"]:
item.connect("activate", lambda x: self.Blueman.bond(self.SelectedDevice))
else:
item.props.sensitive = False
if not row["trusted"]:
item = create_menuitem(_("_Trust"), "blueman-trust")
item.connect("activate", lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
self.append(item)
item.show()
else:
item = create_menuitem(_("_Untrust"), "blueman-untrust")
self.append(item)
item.connect("activate", lambda x: self.Blueman.toggle_trust(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Mark/Unmark this device as trusted")
item = create_menuitem(_("_Setup..."), "document-properties")
self.append(item)
item.connect("activate", lambda x: self.Blueman.setup(self.SelectedDevice))
item.show()
item.props.tooltip_text = _("Run the setup assistant for this device")
def on_rename(_item, device):
def on_response(dialog, response_id):
if response_id == Gtk.ResponseType.ACCEPT:
device.set('Alias', alias_entry.get_text())
elif response_id == 1:
device.set('Alias', '')
dialog.destroy()
builder = Gtk.Builder()
builder.set_translation_domain("blueman")
bind_textdomain_codeset("blueman", "UTF-8")
builder.add_from_file(UI_PATH + "/rename-device.ui")
dialog = builder.get_object("dialog")
dialog.set_transient_for(self.Blueman)
dialog.props.icon_name = "blueman"
alias_entry = builder.get_object("alias_entry")
alias_entry.set_text(device['Alias'])
dialog.connect("response", on_response)
dialog.present()
item = Gtk.MenuItem.new_with_mnemonic("R_ename device...")
item.connect('activate', on_rename, self.SelectedDevice)
self.append(item)
item.show()
item = Gtk.SeparatorMenuItem()
item.show()
self.append(item)
item = create_menuitem(_("_Remove..."), "edit-delete")
item.connect("activate", lambda x: self.Blueman.remove(self.SelectedDevice))
self.append(item)
item.show()
item.props.tooltip_text = _("Remove this device from the known devices list")
