def _init_actions(self):
app = self.props.application
self._add_action = Gio.SimpleAction.new('torrent_add',
GLib.VariantType('s'))
self._add_action.connect('activate', self._on_torrent_add)
self.add_action(self._add_action)
app.set_accels_for_action("win.torrent_add('')", ['<Primary>o'])
self._add_uri_action = Gio.SimpleAction.new('torrent_add_uri',
GLib.VariantType('s'))
self._add_uri_action.connect('activate', self._on_torrent_add)
self.add_action(self._add_uri_action)
app.set_accels_for_action("win.torrent_add_uri('')",
['<Primary>l', '<Primary>u'])
Action = namedtuple('Action', ('name', 'value', 'callback'))
actions = (
Action('filter_status', GLib.Variant('i', -1),
self._on_status_filter),
Action('filter_tracker', GLib.Variant('s', _('Any')),
self._on_tracker_filter),
Action('filter_directory', GLib.Variant('s', _('Any')),
self._on_directory_filter),
)
for action in actions:
act = Gio.SimpleAction.new_stateful(action.name,
action.value.get_type(),
action.value)
act.connect('change-state', action.callback)
self.add_action(act)
def _contacts_as_dbus_structure(self, contacts):
"""
Get info from list of Contact objects and create dbus dict
"""
if not contacts:
return None
prim_contact = None # primary contact
for contact in contacts:
if prim_contact is None or contact.priority > prim_contact.priority:
prim_contact = contact
contact_dict = {}
name = prim_contact.name if prim_contact.name is not None else ''
contact_dict['name'] = GLib.Variant('s', name)
contact_dict['show'] = GLib.Variant('s', prim_contact.show)
contact_dict['jid'] = GLib.Variant('s', prim_contact.jid)
resources = GLib.VariantBuilder(GLib.VariantType('a(sis)'))
for contact in contacts:
resource_props = (contact.resource, int(contact.priority),
contact.status)
resources.add_value(GLib.Variant('(sis)', resource_props))
contact_dict['resources'] = resources.end()
groups = GLib.VariantBuilder(GLib.VariantType('as'))
for group in prim_contact.groups:
groups.add_value(GLib.Variant('s', group))
contact_dict['groups'] = groups.end()
return contact_dict
def __init__(self, **kwargs: Any):
Gtk.ApplicationWindow.__init__(self, **kwargs)
# noinspection PyCallByClass,PyArgumentList
self.set_icon(
GdkPixbuf.Pixbuf.new_from_resource(
"/org/readmachine/ocrd-browser/icons/icon.png"))
self.view_manager = ViewManager(self, self.view_container)
self.current_page_id: Optional[str] = None
# noinspection PyTypeChecker
self.document = Document.create(emitter=self.emit)
self.actions = ActionRegistry(for_widget=self)
self.actions.create('close')
self.actions.create('goto_first')
self.actions.create('go_back')
self.actions.create('go_forward')
self.actions.create('goto_last')
self.actions.create('page_remove')
self.actions.create('page_properties')
self.actions.create('close_view', param_type=GLib.VariantType("s"))
self.actions.create('split_view', param_type=GLib.VariantType("(ssb)"))
self.actions.create('create_view', param_type=GLib.VariantType("s"))
self.actions.create('replace_view',
param_type=GLib.VariantType("(ss)"))
self.actions.create('toggle_edit_mode', state=GLib.Variant('b', False))
self.actions.create('save')
self.actions.create('save_as')
self.connect('delete-event', self.on_delete_event)
self.page_list = PagePreviewList(self.document)
self.page_list_scroller.add(self.page_list)
self.page_list.connect('page_activated', self.on_page_activated)
self.page_list.connect('pages_selected', self.on_pages_selected)
for id_, view in self.view_registry.get_view_options().items():
menu_item = Gtk.ModelButton(visible=True,
centered=False,
halign=Gtk.Align.FILL,
label=view,
hexpand=True)
menu_item.set_detailed_action_name(
'win.create_view("{}")'.format(id_))
self.view_menu_box.pack_start(menu_item, True, True, 0)
self.view_manager.set_root_view(ViewPage)
# self.view_manager.split(None, ViewPage, False)
self.update_ui()
def import_to_repo(self):
logging.info("Trying to use %s extractor...", self.__class__.__name__)
### Mmap the flatpak file and create a GLib.Variant from it
mapped_file = GLib.MappedFile.new(self._src_path, False)
delta = GLib.Variant.new_from_bytes(
GLib.VariantType(OSTREE_STATIC_DELTA_SUPERBLOCK_FORMAT),
mapped_file.get_bytes(), False)
### Parse flatpak metadata
# Use get_child_value instead of array index to avoid
# slowdown (constructing the whole array?)
checksum_variant = delta.get_child_value(3)
OSTree.validate_structureof_csum_v(checksum_variant)
metadata_variant = delta.get_child_value(0)
logging.debug("Metadata keys: %s", metadata_variant.keys())
commit = OSTree.checksum_from_bytes_v(checksum_variant)
self._metadata = {}
logging.debug("===== Start Metadata =====")
for key in FlatpakImporter.METADATA_KEYS:
try:
self._metadata[key] = metadata_variant[key]
except KeyError:
self._metadata[key] = ''
logging.debug(" %s: %s", key, self._metadata[key])
logging.debug("===== End Metadata =====")
self._apply_commit_to_repo(commit, self._metadata['ref'])
def do_handle_local_options(self, options):
url_variant = options.lookup_value('url', GLib.VariantType('s'))
if url_variant:
self.register()
self.activate_action('new-window', url_variant)
return 0
return -1
def get_properties(self, bus, name, path):
""" Returns properties of a device
Parameters
----------
bus: Gio.DBusConnection
The bus to use
name: str
The name of the bus to use
path: str
The path to use
Returns
-------
res: GLib.Variant or None (default None)
The object properties
"""
args = GLib.Variant('(s)', ('org.bluez.Device1', )) # Parameters
reply = GLib.VariantType('(a{sv})') # reply_type
res = self.bus_call_sync('org.freedesktop.DBus.Properties',
'GetAll',
name=name,
path=path,
bus=bus,
args=args,
reply=reply)
return res
def delete_list_item(self, section, key, item):
variant = self.get_variant(section, key)
if variant == None:
printerrr('%s:%s does not exist' % (section, key))
return
if section == 'romaji-typing-rule' or \
section == 'kana-typing-rule' or \
section == 'thumb-typing-rule':
(method, keymap_key) = item
variant_dict = GLib.VariantDict(variant)
keymap = variant_dict.lookup_value(method, None)
keymap_dict = GLib.VariantDict(keymap)
keymap_dict.remove(keymap_key)
keymap = keymap_dict.end()
variant_dict.insert_value(method, keymap)
self.set_variant(section, key, variant_dict.end())
return
if section == 'dict' and key == 'files':
variant_dict = GLib.VariantDict(variant)
variant_dict.remove(item)
self.set_variant(section, key, variant_dict.end())
return
if section == 'dict' and key == 'list':
array = []
for v in variant:
dict_item = DictItem(*v)
if dict_item.id == item:
continue
else:
array.append(
GLib.Variant.new_variant(
DictItem.serialize(dict_item)))
varray = GLib.Variant.new_array(GLib.VariantType('v'), array)
self.set_variant(section, key, varray)
return
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.init_template()
self.client = kwargs['client']
self.client.connect('messages-received', self._on_message_received)
self.client.connect('authenticated', self._on_authenticated)
self.client.connect('auth-failed', self._on_auth_failed)
self.settings = Gio.Settings.new('me.ramkrishna.Eidisi')
for prop in ['username', 'password', 'hostname', 'port']:
self.settings.bind(prop, self.client, prop,
Gio.SettingsBindFlags.GET)
self._add_action = Gio.SimpleAction.new('join', GLib.VariantType('s'))
self._add_action.connect('activate', self._on_join_room)
self.add_action(self._add_action)
displaybuffer = self.chatbox.get_buffer()
displaybuffer.set_text("some sample text for you to see!")
# start authentication
self.client.login()
def _property_read_cb(self, connection, sender, objpath, interface,
propname):
if interface != INTF_DEVICE:
return None
if propname == 'BlueZDevice':
return GLib.Variant.new_object_path(self.bluez_device_objpath)
elif propname == 'Dimensions':
w = GLib.Variant.new_uint32(self.width)
h = GLib.Variant.new_uint32(self.height)
return GLib.Variant.new_tuple(w, h)
elif propname == 'DrawingsAvailable':
ts = GLib.Variant.new_array(
GLib.VariantType('t'),
[GLib.Variant.new_uint64(t) for t in self.drawings.keys()])
return ts
elif propname == 'Listening':
return GLib.Variant.new_boolean(self.listening)
elif propname == 'Live':
return GLib.Variant.new_boolean(self.live)
elif propname == 'BatteryPercent':
return GLib.Variant.new_uint32(self.battery_percent)
elif propname == 'BatteryState':
return GLib.Variant.new_uint32(self.battery_state.value)
return None
def _create_actions(self):
self.action_group = Gio.SimpleActionGroup()
self.insert_action_group("markers", self.action_group)
self.app.shortcuts.register_group("markers", _("Markers"), position=70)
self.add_marker_action = Gio.SimpleAction.new("marker-add",
GLib.VariantType("mx"))
self.add_marker_action.connect("activate", self._add_marker_cb)
self.action_group.add_action(self.add_marker_action)
self.app.shortcuts.add("markers.marker-add(@mx nothing)",
["<Primary><Shift>m"], self.add_marker_action,
_("Add a marker"))
self.seek_backward_marker_action = Gio.SimpleAction.new(
"seek-backward-marker", None)
self.seek_backward_marker_action.connect("activate",
self._seek_backward_marker_cb)
self.action_group.add_action(self.seek_backward_marker_action)
self.app.shortcuts.add(
"markers.seek-backward-marker", ["<Alt>Left"],
self.seek_backward_marker_action,
_("Seek to the first marker before the playhead"))
self.seek_forward_marker_action = Gio.SimpleAction.new(
"seek-forward-marker", None)
self.seek_forward_marker_action.connect("activate",
self._seek_forward_marker_cb)
self.action_group.add_action(self.seek_forward_marker_action)
self.app.shortcuts.add(
"markers.seek-forward-marker", ["<Alt>Right"],
self.seek_forward_marker_action,
_("Seek to the first marker after the playhead"))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.maximize()
self._tuhi = TuhiDBusClientManager()
action = Gio.SimpleAction.new_stateful('orientation',
GLib.VariantType('s'),
GLib.Variant('s', 'landscape'))
action.connect('activate', self._on_orientation_changed)
action.set_state(GLib.Variant.new_string(Config().orientation))
self.add_action(action)
builder = Gtk.Builder.new_from_resource(
'/org/freedesktop/Tuhi/ui/AppMenu.ui')
menu = builder.get_object("primary-menu")
self.menubutton1.set_menu_model(menu)
ep = ErrorPerspective()
self._add_perspective(ep)
self.stack_perspectives.set_visible_child_name(ep.name)
self._signals = []
# the dbus bindings need more async...
if not self._tuhi.online:
self._tuhi.connect('notify::online', self._on_dbus_online)
else:
self._on_dbus_online()
def variant_list(l):
""" Converts a list to a GLib.Variant
"""
# If this is a zero-length array, handle it specially
if len(l) == 0:
return GLib.Variant.new_array(GLib.VariantType("v"))
# Build the array from each entry
builder = GLib.VariantBuilder(GLib.VariantType("a*"))
for item in l:
if item is None:
item = ""
builder.add_value(ModulemdUtil.python_to_variant(item))
return builder.end()
def __init__(self, unit, cb):
# try connecting to the bus
try:
self.system_bus = Gio.bus_get_sync(Gio.BusType.SYSTEM)
self.system_bus.call_sync(
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"Subscribe",
None, # parameters
None, # reply type
Gio.DBusCallFlags.NONE,
-1, # timeout
None, # cancellable
)
self.system_bus.call(
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"LoadUnit",
GLib.Variant("(s)", (unit, )), # parameters
GLib.VariantType("(o)"), # reply type
Gio.DBusCallFlags.NONE,
-1, # timeout
None, # cancellable
self._on_get_unit,
cb, # user_data
)
self.proxy = None
self.properties_changed_signal = None
except GLib.Error:
pass
except IOError:
pass
def introspect(self, bus, name, path):
""" Instrospect an object on DBus
Parameters
----------
bus: Gio.DBusConnection
The bus to use
name: str
The name of the bus to use
path: str
The path to use
Returns
-------
res: GLib.Variant or None (default None)
The object introspection results
"""
res = self.bus_call_sync('org.freedesktop.DBus.Introspectable',
'Introspect',
name=name,
path=path,
bus=bus,
reply=GLib.VariantType('(s)'))
return res
def __init__(self):
"""
Init actions
"""
self.__user_scan = False
settings_action = Gio.SimpleAction.new("settings",
GLib.VariantType("i"))
settings_action.connect("activate", self.__on_settings_activate)
App().add_action(settings_action)
update_action = Gio.SimpleAction.new("update_db", None)
update_action.connect("activate", self.__on_update_db_activate)
App().add_action(update_action)
fullscreen_action = Gio.SimpleAction.new("fullscreen", None)
App().player.connect("current-changed", self.__on_current_changed,
fullscreen_action)
fullscreen_action.set_enabled(False)
fullscreen_action.connect("activate", self.__on_fullscreen_activate)
App().add_action(fullscreen_action)
equalizer_action = Gio.SimpleAction.new("equalizer", None)
equalizer_action.connect("activate", self.__on_equalizer_activate)
App().set_accels_for_action("app.equalizer", ["<Shift><Alt>e"])
App().add_action(equalizer_action)
show_sidebar = App().settings.get_value("show-sidebar")
sidebar_action = Gio.SimpleAction.new_stateful(
"sidebar", None, GLib.Variant.new_boolean(show_sidebar))
sidebar_action.connect("change-state", self.__on_sidebar_change_state)
App().add_action(sidebar_action)
about_action = Gio.SimpleAction.new("about", None)
about_action.connect("activate", self.__on_about_activate)
App().add_action(about_action)
shortcuts_action = Gio.SimpleAction.new("shortcuts", None)
shortcuts_action.connect("activate", self.__on_shortcuts_activate)
App().add_action(shortcuts_action)
quit_action = Gio.SimpleAction.new("quit", None)
quit_action.connect("activate", lambda x, y: App().quit(True))
App().add_action(quit_action)
seek_action = Gio.SimpleAction.new("seek", GLib.VariantType.new("i"))
seek_action.connect("activate", self.__on_seek_action)
App().add_action(seek_action)
player_action = Gio.SimpleAction.new("shortcut",
GLib.VariantType.new("s"))
player_action.connect("activate", self.__on_player_action)
App().add_action(player_action)
search_action = Gio.SimpleAction.new("search",
GLib.VariantType.new("s"))
App().add_action(search_action)
App().set_accels_for_action("app.search('')", ["<Control>f"])
App().scanner.connect("scan-finished", self.__on_scan_finished)
self.__setup_global_shortcuts()
self.enable_special_shortcuts(True)
def update_connection(self, connection_path, connection_data):
return self.bus.call_sync(self.BUS_NAME, connection_path,
self.DBUS_INTERFACE_NAME + '.Connection',
"Update",
GLib.Variant.new_tuple(connection_data),
GLib.VariantType("()"),
Gio.DBusCallFlags.NONE, -1, None)
def get_imlist(self):
bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
res = bus.call_sync(
bus_name='org.fcitx.Fcitx',
object_path='/inputmethod',
interface_name='org.freedesktop.DBus.Properties',
method_name='Get',
parameters=GLib.Variant('(ss)',
('org.fcitx.Fcitx.InputMethod', 'IMList')),
reply_type=GLib.VariantType('(v)'),
flags=Gio.DBusCallFlags.NONE,
timeout_msec=-1,
cancellable=None)
list = []
if res != None:
data = res.unpack()[0]
for atom in data:
item = ImItem()
item.name = atom[0]
item.unique_name = atom[1]
item.langcode = atom[2]
item.enable = atom[3]
list.append(item)
return list
def eknservices_shards_for_application(conn,
app_id,
eknservices_name,
search_provider_name,
cancellable,
callback):
'''Ask eknservices for the application's shards and pass to callback.
:app_id: is the id of the application to make the query on.
:callback: is a GAsyncReady callback.
'''
conn.call(
_EKNSERVICES_DBUS_NAME_TEMPLATE.format(
eknservices_name=eknservices_name,
search_provider_name=search_provider_name
),
os.path.join(
_EKNSERVICES_BASE_DBUS_PATH_TEMPLATE.format(
eknservices_name=eknservices_name,
search_provider_name=search_provider_name
),
encode_dbus_name(app_id)
),
_METADATA_INTERFACE,
'Shards',
None,
GLib.VariantType('(as)'),
Gio.DBusCallFlags.NONE,
-1,
cancellable,
callback
)
def _on_device_registered(self, device, param):
objpaths = GLib.Variant.new_array(GLib.VariantType('o'),
[GLib.Variant.new_object_path(d.objpath)
for d in self._devices if d.registered])
self.properties_changed({'Devices': objpaths})
if not device.registered and self._is_searching:
self._emit_unregistered_signal(device)
def get_connection_path_by_uuid(self, uuid):
"""
Returns connection path as an string
"""
return self.bus.call_sync(
self.BUS_NAME, self.DBUS_OBJECT_PATH, self.DBUS_INTERFACE_NAME,
"GetConnectionByUuid",
GLib.Variant.new_tuple(GLib.Variant.new_string(uuid)),
GLib.VariantType("(o)"), Gio.DBusCallFlags.NONE, -1, None)[0]
def list_names_sync(self):
"""Get the name of every client connected to the bus."""
conn = self.get_connection()
result = conn.call_sync('org.freedesktop.DBus',
'/org/freedesktop/DBus',
'org.freedesktop.DBus', 'ListNames', None,
GLib.VariantType('(as)'),
Gio.DBusCallFlags.NONE, -1, None)
return result[0]
def __init__(self):
super().__init__()
self.set_size_request(300, -1)
actions = Gio.SimpleActionGroup()
action = Gio.SimpleAction.new('section', GLib.VariantType('s'))
action.connect('activate', self._section_activate_cb)
actions.add_action(action)
self.insert_action_group('toc_popover', actions)
def replay_unknown_sequences(unknown_events: Query) -> None:
for unknown in unknown_events:
event_id = str(unknown.event_id)
if event_id in IGNORED_EVENTS:
unknown_events.session.delete(unknown)
continue
event_model = SEQUENCE_EVENT_MODELS[event_id]
# This event UUID was unknown but is now known, let's process it
# The payload is really the variant containing all the events in the sequence
events = GLib.Variant.new_from_bytes(GLib.VariantType('a(xmv)'),
GLib.Bytes.new(unknown.payload_data),
False)
start_variant, *_progress_variants, stop_variant = get_child_values(events)
# For now, we ignore progress events entirely. We also assume the stop event always has a
# null payload. This works for most sequence events we care about in priority.
# TODO: Figure this out for the more complex events
start_relative_timestamp = start_variant.get_child_value(0).get_int64()
payload = start_variant.get_child_value(1)
started_at = get_event_datetime(unknown.request.absolute_timestamp,
unknown.request.relative_timestamp,
start_relative_timestamp)
stop_relative_timestamp = stop_variant.get_child_value(0).get_int64()
stopped_at = get_event_datetime(unknown.request.absolute_timestamp,
unknown.request.relative_timestamp,
stop_relative_timestamp)
try:
# Mypy complains here, even though this should be fine:
# https://github.com/dropbox/sqlalchemy-stubs/issues/97
sequence = event_model(request_id=unknown.request_id, # type: ignore
user_id=unknown.user_id, started_at=started_at,
stopped_at=stopped_at, payload=payload)
except Exception as e:
if isinstance(e, EmptyPayloadError) and event_id in IGNORED_EMPTY_PAYLOAD_ERRORS:
unknown_events.session.delete(unknown)
continue
# The event is now invalid
log.exception('An error occured while processing the event:')
# Mypy complains here, even though this should be fine:
# https://github.com/dropbox/sqlalchemy-stubs/issues/97
sequence = InvalidSequence(request_id=unknown.request_id, # type: ignore
user_id=unknown.user_id, event_id=event_id, payload=events,
error=str(e))
unknown_events.session.add(sequence)
unknown_events.session.delete(unknown)
def merge_variants(self, va, vb):
logging.debug("Merging variants")
are_variants = va.get_type_string() == "v" and \
vb.get_type_string() == "v"
if are_variants:
va = va.get_child_value(0)
vb = vb.get_child_value(0)
if va.get_type_string() != vb.get_type_string():
logging.error("Can't merge variants of different types")
if are_variants:
return GLib.Variant("v", va)
return va
dict_type = GLib.VariantType("a{s*}")
if not va.is_of_type(dict_type):
if are_variants:
return GLib.Variant("v", vb)
return vb
builder = GLib.VariantBuilder.new(va.get_type())
for i in range(va.n_children()):
child_a = va.get_child_value(i)
# key = child_a.get_child_value(0).get_string()[0]
key = child_a.get_child_value(0).get_string()
value_b = vb.lookup_value(key, None)
if value_b is None:
builder.add_value(child_a)
continue
value_a = va.lookup_value(key, None)
merge = self.merge_variants(value_a, value_b)
child_builder = GLib.VariantBuilder.new(child_a.get_type())
child_builder.add_value(child_a.get_child_value(0))
if child_a.get_child_value(1).get_type_string() == "v" and \
merge.get_type_string() != "v":
merge = GLib.Variant("v", merge)
child_builder.add_value(merge)
builder.add_value (child_builder.end())
for i in range(vb.n_children()):
child = vb.get_child_value(i)
key = child.get_child_value(0).get_string()
if va.lookup_value(key, None) is not None:
continue;
builder.add_value (child)
if are_variants:
return GLib.Variant("v", builder.end())
return builder.end()
def properties_changed(self, props, dest=None):
'''
Send a PropertiesChanged signal to the given destination (if any).
The props argument is a { name: value } dictionary of the
property values, the values are GVariant.bool, etc.
'''
builder = GLib.VariantBuilder(GLib.VariantType('a{sv}'))
for name, value in props.items():
de = GLib.Variant.new_dict_entry(GLib.Variant.new_string(name),
GLib.Variant.new_variant(value))
builder.add_value(de)
properties = builder.end()
inval_props = GLib.VariantBuilder(GLib.VariantType('as'))
inval_props = inval_props.end()
self.connection.emit_signal(
dest, self.objpath, 'org.freedesktop.DBus.Properties',
'PropertiesChanged',
GLib.Variant.new_tuple(GLib.Variant.new_string(self.interface),
properties, inval_props))
def _create_actions(self):
self.action_group = Gio.SimpleActionGroup()
self.insert_action_group("markers", self.action_group)
self.app.shortcuts.register_group("markers", _("Markers"), position=70)
self.add_marker_action = Gio.SimpleAction.new("marker-add", GLib.VariantType("mx"))
self.add_marker_action.connect("activate", self._add_marker_cb)
self.action_group.add_action(self.add_marker_action)
self.app.shortcuts.add("markers.marker-add(@mx nothing)", ["<Primary><Shift>m"],
self.add_marker_action, _("Add a marker"))
def do_startup(self):
Gtk.Application.do_startup(self)
# Action: app.about
action = Gio.SimpleAction.new("about", None)
action.connect("activate", lambda a, p: self.about())
self.add_action(action)
# Action: app.settings
action = Gio.SimpleAction.new("settings", None)
action.connect("activate", lambda a, p: self.settings())
self.add_action(action)
# Action: app.quit
action = Gio.SimpleAction.new("quit", None)
action.connect("activate", lambda a, p: self.quit())
self.add_action(action)
self.set_accels_for_action("app.quit", ["<Ctrl>Q", "<Ctrl>W"])
# Action: app.optimize
action = Gio.SimpleAction.new("optimize", None)
action.connect("activate", lambda a, p: self.optimize())
self.add_action(action)
# Action: app.stop-optimization
action = Gio.SimpleAction.new("stop-optimization", None)
action.connect("activate", lambda a, p: self.stop_optimization())
self.add_action(action)
# Action: app.add-image
action = Gio.SimpleAction.new("add-image", GLib.VariantType("s"))
action.connect("activate", lambda a, p: self.add_image(p.get_string()))
self.add_action(action)
# Action: app.clear-images
action = Gio.SimpleAction.new("clear-images", None)
action.connect("activate", lambda a, p: self.clear_images())
self.add_action(action)
# Action: app.open-file
action = Gio.SimpleAction.new("open-file", None)
action.connect("activate", lambda a, p: self.open_file())
self.add_action(action)
self.set_accels_for_action("app.open-file", ["<Ctrl>O"])
# Apply GTK theme
if self.config.get("interface", "gtk-theme-name") != "default":
gtk_themes_helpers.set_gtk_theme_name(
self.config.get("interface", "gtk-theme-name"))
gtk_themes_helpers.set_gtk_application_prefer_dark_theme(
self.config.getboolean("interface",
"gtk-application-prefer-dark-theme"))
def serialize_config_object(self, obj):
if not isinstance(obj, dict):
return None
dict_top = GLib.VariantBuilder.new(GLib.VariantType("a{sa{sv}}"))
for key_top in obj.keys():
dict_sub = GLib.VariantDict.new(GLib.Variant("a{sv}", {}))
if not isinstance(obj[key_top], dict):
continue
for key_sub in obj[key_top].keys():
item = gi_json.gvariant_deserialize_data(
json.dumps(obj[key_top][key_sub]), -1, None)
dict_sub.insert_value(key_sub, item)
entry = GLib.VariantBuilder.new(GLib.VariantType("{sa{sv}}"))
entry.add_value(GLib.Variant("s", key_top))
entry.add_value(dict_sub.end())
dict_top.add_value(entry.end())
return dict_top.end()
def _setup_actions(self):
flip = Gio.SimpleAction(name='flip',
parameter_type=GLib.VariantType('b'))
flip.connect('activate', self._flip_action_activated_cb)
self.add_action(flip)
reset = Gio.SimpleAction(name='reset', parameter_type=None)
reset.connect('activate', self._reset_action_activated_cb)
self.add_action(reset)
quit = Gio.SimpleAction(name='quit')
quit.connect('activate', self._quit_action_activated_cb)
self.add_action(quit)
def serialize(cls, dict_item):
builder = GLib.VariantBuilder(GLib.VariantType('r'))
builder.add_value(GLib.Variant.new_string(dict_item.id))
builder.add_value(GLib.Variant.new_string(dict_item.short_label))
builder.add_value(GLib.Variant.new_string(dict_item.long_label))
builder.add_value(GLib.Variant.new_string(dict_item.icon))
builder.add_value(GLib.Variant.new_boolean(dict_item.is_system))
builder.add_value(GLib.Variant.new_int32(dict_item.preview_lines))
builder.add_value(GLib.Variant.new_boolean(dict_item.embed))
builder.add_value(GLib.Variant.new_boolean(dict_item.single))
builder.add_value(GLib.Variant.new_boolean(dict_item.reverse))
builder.add_value(GLib.Variant.new_string(dict_item.encoding))
return builder.end()
