def __on_volume_changed(self, player, data=None):
self.PropertiesChanged(self.__MPRIS_PLAYER_IFACE, {
'Volume': GLib.Variant('d',
Lp().player.volume),
}, [])
def set_reading_direction(self):
self.reading_direction_action.set_state(
GLib.Variant('s', self.reading_direction))
self.controls.set_scale_direction(
self.reading_direction == 'right-to-left')
def _update_columns(self, *args):
value = [(c[1].lower(), c[0]) for c in self.model]
settings.set_value(self.key, GLib.Variant('a(sb)', value))
def _dup_variant(self):
return GLib.Variant('a{sv}', self._dup_variant_as_dict())
def filter_opt(opt):
"""Remove ``None`` values from a dictionary."""
return {k: GLib.Variant(*v) for k, v in opt.items() if v[1] is not None}
def _init_actions(self):
Action = namedtuple(
"Action", ("callback", "type", "enabled", "default", "accel"))
Action.__new__.__defaults__ = (None, None, True, None, None)
actions = {
"browse-games":
Action(lambda *x: open_uri("https://lutris.net/games/")),
"register-account":
Action(lambda *x: open_uri("https://lutris.net/user/register/")),
"disconnect":
Action(self.on_disconnect),
"connect":
Action(self.on_connect),
"synchronize":
Action(lambda *x: self.sync_library()),
"sync-local":
Action(lambda *x: self.open_sync_dialog()),
"add-game":
Action(self.on_add_game_button_clicked),
"preferences":
Action(self.on_preferences_activate),
"manage-runners":
Action(self.on_manage_runners),
"about":
Action(self.on_about_clicked),
"show-installed-only":
Action(
self.on_show_installed_state_change,
type="b",
default=self.filter_installed,
accel="<Primary>h",
),
"show-installed-first":
Action(
self.on_show_installed_first_state_change,
type="b",
default=self.show_installed_first,
),
"toggle-viewtype":
Action(self.on_toggle_viewtype),
"icon-type":
Action(self.on_icontype_state_change,
type="s",
default=self.icon_type),
"view-sorting":
Action(self.on_view_sorting_state_change,
type="s",
default=self.view_sorting),
"view-sorting-ascending":
Action(
self.on_view_sorting_direction_change,
type="b",
default=self.view_sorting_ascending,
),
"use-dark-theme":
Action(self.on_dark_theme_state_change,
type="b",
default=self.use_dark_theme),
"show-tray-icon":
Action(self.on_tray_icon_toggle,
type="b",
default=self.show_tray_icon),
"show-side-bar":
Action(
self.on_sidebar_state_change,
type="b",
default=self.sidebar_visible,
accel="F9",
),
}
self.actions = {}
app = self.props.application
for name, value in actions.items():
if not value.type:
action = Gio.SimpleAction.new(name)
action.connect("activate", value.callback)
else:
default_value = None
param_type = None
if value.default is not None:
default_value = GLib.Variant(value.type, value.default)
if value.type != "b":
param_type = default_value.get_type()
action = Gio.SimpleAction.new_stateful(name, param_type,
default_value)
action.connect("change-state", value.callback)
self.actions[name] = action
if value.enabled is False:
action.props.enabled = False
self.add_action(action)
if value.accel:
app.add_accelerator(value.accel, "win." + name)
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")
def grant_permissions(self, doc_id, app_id, permissions):
self.proxy.call_sync(
"GrantPermissions",
GLib.Variant('(ssas)', (doc_id, app_id, permissions)), 0, -1, None)
def lookup(self, path):
res = self.proxy.call_sync(
"Lookup", GLib.Variant('(ay)', (filename_to_ay(path), )), 0, -1,
None)
return res[0]
def Get(self, interface_name, property_name): type = self.readable_properties[interface_name + "." + property_name] result = getattr(self.object, property_name) return GLib.Variant(type, result)
def get_mount_path(self):
res = self.proxy.call_sync("GetMountPoint", GLib.Variant('()', ()), 0,
-1, None)
return bytearray(res[0][:-1]).decode("utf-8")
def onPropertiesChanged(iface, changed, invalidated):
changed = {key: GLib.Variant(self.readable_properties[iface + "." + key], val) for key, val in changed.items()}
args = GLib.Variant("(sa{sv}as)", (iface, changed, invalidated))
self.SignalEmitted("org.freedesktop.DBus.Properties", "PropertiesChanged", args)
def EmitSignal(iface, signal):
return lambda *args: self.SignalEmitted(iface.name, signal.name, GLib.Variant("(" + "".join(s.signature for s in signal.args) + ")", args))
def __on_status_changed(self, data=None):
properties = {'PlaybackStatus': GLib.Variant('s', self.__get_status())}
self.PropertiesChanged(self.__MPRIS_PLAYER_IFACE, properties, [])
def set_window_size(list):
g_variant = GLib.Variant('ai', list)
setting.set_value(window_size, g_variant)
def delete(self, doc_id):
self.proxy.call_sync("Delete", GLib.Variant('(s)', (doc_id, )), 0, -1,
None)
del self.docs[doc_id]
def close(self):
param = GLib.Variant('(u)', (self._return_id, ))
self.call_sync('CloseNotification', param, Gio.DBusProxyFlags.NONE, -1,
None)
self._return_id = None
def set_value(self, itr, column, value):
var = GLib.Variant(self.get_column_schema(column), value)
if isinstance(itr, int):
itr = self.get_iter_at_row(itr)
Dee.Model.set_value(self, itr, column, var)
def _prepare_arguments(signature: str,
args: Collection[Any]) -> Optional[GLib.Variant]:
return GLib.Variant(f"({signature})", args) if signature else None
def new(name, parameter_type=None):
return Gio.SimpleAction.new_stateful(name, parameter_type,
GLib.Variant("b", False))
def test_get_metadata_has_track_number_in_album(core, player):
core.tracklist.add([Track(uri="dummy:a", track_no=7)])
core.playback.play().get()
assert player.Metadata["xesam:trackNumber"] == GLib.Variant("i", 7)
def set_state(self, value):
Action.set_state(self, GLib.Variant("b", value))
def _set_override(self, name, v):
items = self._dup_variant_as_dict()
items[name] = self.VARIANT_TYPES[name](v)
n = GLib.Variant('a{sv}', items)
self._settings.set_value('overrides', n)
self._variant = self._settings.get_value("overrides")
def __init__(self):
super(Udisks2, self).__init__()
self.no_options = GLib.Variant('a{sv}', {})
self.read_only = GLib.Variant('a{sv}', {'options': GLib.Variant('s', 'ro')})
self.no_interaction = GLib.Variant('a{sv}', {'auth.no_user_interaction': GLib.Variant('b', True)})
self.devices = Tree()
def set_borders_crop(self):
self.borders_crop_action.set_state(GLib.Variant(
'b', self.borders_crop))
def set_last_opened_list(list):
g_variant = GLib.Variant('as', list)
setting.set_value(last_opened_list, g_variant)
def set_scaling(self):
self.scaling_action.set_state(GLib.Variant('s', self.scaling))
def set_last_used_composite_key(list):
g_variant = GLib.Variant('aas', list)
setting.set_value(last_used_composite_key, g_variant)
def _update_filter_string(self, *args):
value = [(row[0], row[1], row[2]) for row in self.model]
settings.set_value(self.key, GLib.Variant('a(sbs)', value))
def __update_metadata(self):
if self.__get_status() == 'Stopped':
self.__metadata = {}
else:
if Lp().player.current_track.id >= 0:
track_id = Lp().player.current_track.id
else:
track_id = randint(10000000, 90000000)
self.__metadata['mpris:trackid'] = self.__get_media_id(track_id)
track_number = Lp().player.current_track.number
if track_number is None:
track_number = 1
self.__metadata['xesam:trackNumber'] = GLib.Variant(
'i', track_number)
self.__metadata['xesam:title'] = GLib.Variant(
's',
Lp().player.current_track.name)
self.__metadata['xesam:album'] = GLib.Variant(
's',
Lp().player.current_track.album.name)
self.__metadata['xesam:artist'] = GLib.Variant(
'as',
Lp().player.current_track.artists)
self.__metadata['xesam:albumArtist'] = GLib.Variant(
'as',
Lp().player.current_track.album_artists)
self.__metadata['mpris:length'] = GLib.Variant(
'x',
Lp().player.current_track.duration * 1000000)
self.__metadata['xesam:genre'] = GLib.Variant(
'as',
Lp().player.current_track.genres)
self.__metadata['xesam:url'] = GLib.Variant(
's',
Lp().player.current_track.uri)
rate = Lp().player.current_track.get_rate()
if rate == Type.NONE:
rate = Lp().player.current_track.get_popularity()
self.__metadata["xesam:userRating"] = GLib.Variant('d', rate / 5)
if Lp().player.current_track.id == Type.RADIOS:
cover_path = Lp().art.get_radio_cache_path(
", ".join(Lp().player.current_track.artists),
ArtSize.MONSTER)
elif Lp().player.current_track.id == Type.EXTERNALS:
cover_path = "/tmp/lollypop_mpris.jpg"
pixbuf = Lp().art.pixbuf_from_tags(
GLib.filename_from_uri(Lp().player.current_track.uri)[0],
ArtSize.MONSTER)
if pixbuf is not None:
pixbuf.savev(cover_path, "jpeg", ["quality"], ["90"])
else:
cover_path = Lp().art.get_album_cache_path(
Lp().player.current_track.album, ArtSize.MONSTER)
if cover_path is not None:
self.__metadata['mpris:artUrl'] = GLib.Variant(
's', "file://" + cover_path)
elif 'mpris:artUrl' in self.__metadata:
self.__metadata['mpris:artUrl'] = GLib.Variant('s', '')
