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()