def __init__(self, installation, config=None, is_cache_repo=False): self.installation = installation self.installation_path = self.installation.get_path().get_path() self.config = config if self.config is None: self.config = eib.get_config() self.is_cache_repo = is_cache_repo self.install_refs = None # Get architecture from generic flatpak section, falling back to # default arch for host. The config default is an empty string, # so the direct fallback mechanism doesn't work. self.arch = self.config.get('flatpak', 'arch', fallback=None) if not self.arch: self.arch = Flatpak.get_default_arch() logger.info('Using flatpak arch %s', self.arch) # Get locales configuration from generic flatpak section self.locales = self.config.get('flatpak', 'locales', fallback=()).split() if self.locales: logger.info('Using flatpak locales %s', ' '.join(self.locales)) # See if collection IDs should be set self.enable_p2p_updates = self.config.getboolean('flatpak', 'enable_p2p_updates', fallback=False) # See if extra-languages should be set self.set_extra_languages = self.config.getboolean( 'flatpak', 'set_extra_languages', fallback=False) self.remotes = OrderedDict() for sect in self.config.sections(): head, sep, name = sect.partition(self.REMOTE_PREFIX) if sep == '' or head != '': # Not a section beginning with the prefix continue if name == '': # No name after the prefix raise FlatpakError('No remote name suffix in config section', sect) # Skip if the remote is disabled remote_enabled = self.config.getboolean(sect, 'enable', fallback=True) if not remote_enabled: logger.info('Remote %s disabled, skipping', name) continue # Pass the remote options as keyword arguments to # FlatpakRemote after removing unrecognized options remote_options = dict(self.config.items(sect)) remote_options.pop('enable', None) logger.debug('Remote %s options: %s', name, remote_options) self.remotes[name] = FlatpakRemote(self, name, **remote_options)
def process_full_flatpak_installation(cache): fp_time = time.time() arch = Flatpak.get_default_arch() fp_sys = get_fp_sys() flatpak_remote_infos = {} try: for remote in fp_sys.list_remotes(): _process_remote(cache, fp_sys, remote, arch) remote_name = remote.get_name() try: for ref in fp_sys.list_installed_refs_by_kind( Flatpak.RefKind.APP, None): # All remotes will see installed refs, but the installed refs will always # report their correct origin, so only add installed refs when they match the remote. if ref.get_origin() == remote_name: _add_package_to_cache(cache, ref, remote.get_url(), True) except GLib.Error as e: print(e.message) flatpak_remote_infos[remote_name] = FlatpakRemoteInfo(remote) except GLib.Error as e: print("Installer: flatpak - could not get remote list", e.message) cache = {} print('Installer: Processing Flatpaks for cache took %0.3f ms' % ((time.time() - fp_time) * 1000.0)) return cache, flatpak_remote_infos
def maybe_sync_appstream(self, executor, source): """ Check if appstream data needs updating """ # Do we need appstream data update? fremote = source.get_remote() modtime = 0 try: updatefile = fremote.get_appstream_timestamp() finfo = updatefile.query_info("*", 0, None) modtime = finfo.get_modification_time().tv_sec print(modtime) except Exception as e: print(e) time_now = GLib.get_current_time() if time_now - modtime < APPSTREAM_THRESHOLD_SECS: print("AppStream data for {} is up to date".format(source.name)) print(time_now - modtime) return self.executor.set_progress_string(_("Updating AppStream data")) self.client.update_appstream_sync( source.name, Flatpak.get_default_arch(), # Use local architecture None) self.executor = None print("flatpak appstream synced")
def maybe_sync_appstream(self, executor, source): """ Check if appstream data needs updating """ # Do we need appstream data update? fremote = source.get_remote() modtime = 0 try: updatefile = fremote.get_appstream_timestamp() finfo = updatefile.query_info("*", 0, None) modtime = finfo.get_modification_time().tv_sec print(modtime) except Exception as e: print(e) time_now = GLib.get_current_time() if time_now - modtime < APPSTREAM_THRESHOLD_SECS: print("AppStream data for {} is up to date".format(source.name)) print(time_now - modtime) return self.executor.set_progress_string(_("Updating AppStream data")) self.client.update_appstream_sync( source.name, Flatpak.get_default_arch(), # Use local architecture None) self.executor = None print("flatpak appstream synced")
def populate_category(self, storage, category): """ Populate the storage with refs from the given category """ if not category.get_id().startswith("flatpak:"): return remote_apps = self.client.list_remote_refs_sync( category.source.name, None) for remote_app in remote_apps: # Only want apps if not remote_app.get_kind() == Flatpak.RefKind.APP: continue # Only support native arch if remote_app.get_arch() != Flatpak.get_default_arch(): continue item = self.build_item(remote_app) storage.add_item(item.get_id(), item, PopulationFilter.CATEGORY)
def populate_category(self, storage, category): """ Populate the storage with refs from the given category """ if not category.get_id().startswith("flatpak:"): return remote_apps = self.client.list_remote_refs_sync( category.source.name, None) for remote_app in remote_apps: # Only want apps if not remote_app.get_kind() == Flatpak.RefKind.APP: continue # Only support native arch if remote_app.get_arch() != Flatpak.get_default_arch(): continue item = self.build_item(remote_app) storage.add_item(item.get_id(), item, PopulationFilter.CATEGORY)
def __init__(self): #determine if Superuser or not to determine install target if getpass.getuser() == "root": self.superuser = True else: self.superuser = False self.arch = Flatpak.get_default_arch() self.item_count = 0 self.current_count = 0 self.taskstbinstalled = {} self.taskstbupdated = {} self.taskstbremoved = {} self.flatpakoverridesiceaccess = ["org.mozilla.firefox"] self.flatpakoverridesonlyadwaita = ["org.mozilla.firefox"] if self.superuser == True: self.flatpakclassthing = Flatpak.Installation.new_system() self.flatpakclassthingalt = self.flatpakclassthing else: self.flatpakclassthing = Flatpak.Installation.new_user() self.flatpakclassthingalt = Flatpak.Installation.new_system() self.transaction = Flatpak.Transaction.new_for_installation(self.flatpakclassthing) self.flatpakremotes = self.flatpakclassthing.list_remotes() if self.flatpakclassthing != self.flatpakclassthingalt: for flatpakremote in self.flatpakclassthingalt.list_remotes(): if flatpakremote not in self.flatpakremotes: self.flatpakremotes.append(flatpakremote) self.all_refs = [] for remote_name in self.flatpakremotes: try: self.all_refs.extend(self.flatpakclassthing.list_remote_refs_sync(remote_name.get_name(), None)) if self.flatpakclassthing != self.flatpakclassthingalt: for i in self.flatpakclassthingalt.list_remote_refs_sync(remote_name.get_name(), None): if i not in self.all_refs: self.all_refs.append(i) except: try: self.all_refs.extend(self.flatpakclassthingalt.list_remote_refs_sync(remote_name.get_name(), None)) except: pass
def main(): # Send logging messages both to the console and the journal logging.basicConfig(level=logging.INFO) logging.root.addHandler(journal.JournalHandler()) parser = argparse.ArgumentParser() parser.add_argument('--debug', dest='debug', action='store_true') parser.add_argument('--app-id', dest='app_id', help='Flatpak App ID', type=str, required=True) parser.add_argument('--remote', dest='remote', help='Flatpak Remote', type=str, required=True) parser.add_argument('--branch', dest='branch', help='Flatpak Branch', type=str, default='', required=False) parser.add_argument('--required-archs', dest='required_archs', default=[], nargs='*', type=str) parsed_args = parser.parse_args() if parsed_args.debug: logging.root.setLevel(logging.DEBUG) if parsed_args.required_archs and Flatpak.get_default_arch( ) not in parsed_args.required_archs: exit_with_error( "Found installation of unsupported architecture: {}".format( parsed_args.required_archs)) InstallAppHelperInstaller(parsed_args.app_id, parsed_args.remote, parsed_args.branch) sys.exit(0)
def main(): # Send logging messages both to the console and the journal logging.basicConfig(level=logging.INFO) logging.root.addHandler(journal.JournalHandler()) parser = argparse.ArgumentParser() parser.add_argument('--debug', dest='debug', action='store_true') parsed_args = parser.parse_args() if parsed_args.debug: logging.root.setLevel(logging.DEBUG) app_arch = Flatpak.get_default_arch() if app_arch != 'x86_64': exit_with_error("Found installation of unsupported architecture: %s", app_arch) GoogleChromeInstaller() sys.exit(0)
def checkinstalled(ref, userland): if userland == False: flatpakclassthing = Flatpak.Installation.new_system() else: flatpakclassthing = Flatpak.Installation.new_user() flatpakremotes = flatpakclassthing.list_remotes() all_refs = [] for remote_name in flatpakremotes: try: for i in flatpakclassthing.list_remote_refs_sync( remote_name.get_name(), None): if i not in all_refs: all_refs.append(i) except: pass ref2 = "" arch = Flatpak.get_default_arch() for i in all_refs: if i.get_name() == ref and i.get_arch() == arch: ref2 = i try: iref = flatpakclassthing.get_installed_ref(ref2.get_kind(), ref2.get_name(), ref2.get_arch(), ref2.get_branch(), None) if iref: if ref2 in flatpakclassthing.list_installed_refs_for_update( None): return (3) else: return (1) except GLib.Error: pass except AttributeError: # bad/null ref pass return (2)
app_launcher_path = os.path.join(app_path, 'files', 'bin', 'eos-google-chrome-app') if not os.path.exists(app_launcher_path): exit_with_error("Could not find flatpak launcher for Google Chrome") logging.info("Found flatpak launcher for Google Chrome: %s", repr(app_launcher_path)) return app_launcher_path if __name__ == '__main__': # Send logging messages both to the console and the journal logging.basicConfig(level=logging.INFO) logging.root.addHandler(journal.JournalHandler()) parser = argparse.ArgumentParser() parser.add_argument('--debug', dest='debug', action='store_true') parsed_args, otherargs = parser.parse_known_args() if parsed_args.debug: logging.root.setLevel(logging.DEBUG) # Google Chrome is only available for Intel 64-bit app_arch = Flatpak.get_default_arch() if app_arch != 'x86_64': exit_with_error("Found installation of unsupported architecture: {}".format(app_arch)) GoogleChromeLauncher(otherargs) sys.exit(0)
def _pkginfo_from_file_thread(cache, file, callback): fp_sys = get_fp_sys() path = file.get_path() if path == None: print("Installer: flatpak - no valid .flatpakref path provided") return None ref = None pkginfo = None remote_name = None with open(path) as f: contents = f.read() b = contents.encode("utf-8") gb = GLib.Bytes(b) try: kf = GLib.KeyFile() if kf.load_from_file(path, GLib.KeyFileFlags.NONE): name = kf.get_string("Flatpak Ref", "Name") url = kf.get_string("Flatpak Ref", "Url") try: branch = kf.get_string("Flatpak Ref", "Branch") except GLib.Error as e: if e.code == GLib.KeyFileError.KEY_NOT_FOUND: print( "Installer: flatpak - flatpakref file doesn't have a Branch key, maybe nightly or testing." ) branch = None remote_name = _get_remote_name_by_url(fp_sys, url) if name and remote_name: ref = Flatpak.RemoteRef(remote_name=remote_name, kind=Flatpak.RefKind.APP, arch=Flatpak.get_default_arch(), branch=branch, name=name) print( "Installer: flatpak - using existing remote '%s' for flatpakref file install" % remote_name) else: #If Flatpakref is not installed already try: print( "Installer: flatpak - trying to install new remote for flatpakref file" ) ref = fp_sys.install_ref_file(gb, None) fp_sys.drop_caches(None) remote_name = ref.get_remote_name() print("Installer: flatpak - added remote '%s'" % remote_name) except GLib.Error as e: if e.code != Gio.DBusError.ACCESS_DENIED: # user cancelling auth prompt for adding a remote print( "Installer: could not add new remote to system: %s" % e.message) dialogs.show_flatpak_error(e.message) except GLib.Error as e: print("Installer: flatpak - could not parse flatpakref file: %s" % e.message) dialogs.show_flatpak_error(e.message) if ref: try: remote = fp_sys.get_remote_by_name(remote_name, None) # Add the ref's remote if it doesn't already exist _process_remote(cache, fp_sys, remote, Flatpak.get_default_arch()) # Add the ref to the cache, so we can work with it like any other in mintinstall pkginfo = _add_package_to_cache(cache, ref, remote.get_url(), False) # Fetch the appstream info for the ref global _as_pools with _as_pool_lock: if remote_name not in _as_pools.keys(): _load_appstream_pool(_as_pools, remote) # Some flatpakref files will have a pointer to a runtime .flatpakrepo file # We need to process and possibly add that remote as well. kf = GLib.KeyFile() if kf.load_from_file(path, GLib.KeyFileFlags.NONE): try: url = kf.get_string("Flatpak Ref", "RuntimeRepo") except GLib.Error: url = None if url: # Fetch the .flatpakrepo file r = requests.get(url, stream=True) file = tempfile.NamedTemporaryFile(delete=False) with file as fd: for chunk in r.iter_content(chunk_size=128): fd.write(chunk) # Get the true runtime url from the repo file runtime_repo_url = _get_repofile_repo_url(file.name) if runtime_repo_url: existing = False path = Path(file.name) runtime_remote_name = Path(url).stem # Check if the remote is already installed for remote in fp_sys.list_remotes(None): # See comments below in _remote_from_repo_file_thread about get_noenumerate() use. if remote.get_url( ) == runtime_repo_url and not remote.get_noenumerate( ): print( "Installer: flatpak - runtime remote '%s' already in system, skipping" % runtime_remote_name) existing = True break if not existing: print( "Installer: Adding additional runtime remote named '%s' at '%s'" % (runtime_remote_name, runtime_repo_url)) cmd_v = [ 'flatpak', 'remote-add', '--from', runtime_remote_name, file.name ] add_repo_proc = subprocess.Popen(cmd_v) retcode = add_repo_proc.wait() fp_sys.drop_caches(None) os.unlink(file.name) except GLib.Error as e: print("Installer: could not process .flatpakref file: %s" % e.message) dialogs.show_flatpak_error(e.message) GLib.idle_add(callback, pkginfo, priority=GLib.PRIORITY_DEFAULT)
def _get_theme_refs(fp_sys, remote_name, ref=None): if ref: arch = ref.get_arch() else: arch = Flatpak.get_default_arch() theme_refs = [] gtksettings = Gtk.Settings.get_default() icon_theme = "org.freedesktop.Platform.Icontheme.%s" % gtksettings.props.gtk_icon_theme_name gtk_theme = "org.gtk.Gtk3theme.%s" % gtksettings.props.gtk_theme_name def sortref(ref): try: val = float(ref.get_branch()) except ValueError: val = 9.9 return val for name in (icon_theme, gtk_theme): theme_ref = None try: print("Looking for theme %s in %s" % (name, remote_name)) all_refs = fp_sys.list_remote_refs_sync(remote_name, None) matching_refs = [] for listed_ref in all_refs: if listed_ref.get_name() == name: matching_refs.append(listed_ref) if not matching_refs: continue # Sort highest version first. matching_refs = sorted(matching_refs, key=sortref, reverse=True) for matching_ref in matching_refs: if matching_ref.get_arch() != arch: continue theme_ref = matching_ref print("Found theme ref '%s' in remote %s" % (theme_ref.format_ref(), remote_name)) break # if nothing is found, check other remotes if theme_ref == None: for other_remote in fp_sys.list_remotes(): other_remote_name = other_remote.get_name() if other_remote_name == remote_name: continue print("Looking for theme %s in alternate remote %s" % (name, other_remote_name)) all_refs = fp_sys.list_remote_refs_sync( other_remote_name, None) matching_refs = [] for listed_ref in all_refs: if listed_ref.get_name() == name: matching_refs.append(listed_ref) if not matching_refs: continue # Sort highest version first. matching_refs = sorted(matching_refs, key=sortref, reverse=True) for matching_ref in matching_refs: if matching_ref.get_arch() != arch: continue theme_ref = matching_ref print("Found theme ref '%s' in alternate remote %s" % (theme_ref.format_ref(), other_remote_name)) break if theme_ref: break if theme_ref == None: debug( "Could not locate theme '%s' in any registered remotes" % name) except GLib.Error as e: theme_ref = None debug("Error finding themes for flatpak: %s" % e.message) if theme_ref: theme_refs.append(theme_ref) return theme_refs
help='Flatpak Remote', type=str, required=True) parser.add_argument('--branch', dest='branch', help='Flatpak Branch', type=str, default='', required=False) parser.add_argument('--required-archs', dest='required_archs', default=[], nargs='*', type=str) parsed_args, otherargs = parser.parse_known_args() if parsed_args.debug: logging.root.setLevel(logging.DEBUG) # Some apps are only available for certain architectures if parsed_args.required_archs and Flatpak.get_default_arch( ) not in parsed_args.required_archs: exit_with_error( "Found installation of unsupported architecture: {}".format( parsed_args.required_archs)) InstallAppHelperLauncher(parsed_args.app_id, parsed_args.remote, parsed_args.branch, otherargs) sys.exit(0)
installation.install(test_remote, Flatpak.RefKind.APP, test_app_id, None, test_branch, _progress_callback, None, None) print("\n{} successfully installed".format(test_app_id)) except GLib.Error as e: print("Could not install {}: {}".format(test_app_id, e.message)) # Backup the app now. print("\n2. Backing up app {} to {}...".format(test_app_id, test_backup_dir)) backup_app(test_app_id, test_remote, test_backup_dir, parsed_args.interactive) # Can't restore and app if it's installed! try: print("\n3. Making sure {} is NOT installed before restoring...".format(test_app_id)) installation.uninstall(Flatpak.RefKind.APP, test_app_id, Flatpak.get_default_arch(), test_branch, _progress_callback, None, None) print("\n{} successfully uninstalled".format(test_app_id)) except GLib.Error as e: print("Could not uninstall {}: {}".format(test_app_id, e.message)) # Finally, restore the app. print("\n4. Restoring app {} from {}...".format(test_app_id, test_backup_dir)) restore_app(test_app_id, test_remote, test_backup_dir, parsed_args.interactive) sys.exit(0)
def __init__(self, application, flatpak_installation, tree_model, show_button): self.Application = application self.FlatpakInstallation = flatpak_installation self.RefsToUpdate = flatpak_installation.list_installed_refs_for_update(Gio.Cancellable.new()) self.InstalledRefsList = self.FlatpakInstallation.list_installed_refs() self.FlatHubRefsList = self.FlatpakInstallation.list_remote_refs_sync( "flathub", Gio.Cancellable.new()) self.NonInstalledRefsList = [] for item in self.FlatHubRefsList: self.NonInstalledRefsList.append(item) for item_2 in self.InstalledRefsList: if item.get_name() == item_2.get_name() and \ item.get_arch() == item_2.get_arch() and \ item.get_branch() == item_2.get_branch(): if len(self.NonInstalledRefsList) != 0: self.NonInstalledRefsList.pop(len(self.NonInstalledRefsList) - 1) else: self.NonInstalledRefsList = [] self.FlatpakTransaction = \ Flatpak.Transaction.new_for_installation( self.FlatpakInstallation, Gio.Cancellable.new()) self.FlatpakTransaction.set_default_arch(Flatpak.get_default_arch()) self.FlatpakTransaction.set_disable_dependencies(False) self.FlatpakTransaction.set_disable_prune(False) self.FlatpakTransaction.set_disable_related(False) self.FlatpakTransaction.set_disable_static_deltas(False) self.FlatpakTransaction.set_no_deploy(False) self.FlatpakTransaction.set_no_pull(False) for ref_to_update in self.RefsToUpdate: ref_str = ref_to_update.format_ref() self.FlatpakTransaction.add_update(ref_str, None, None) self.TreeModel = tree_model self.HeaderBarShowButton = show_button try: update_all_gui_file = "/usr/share/pardus/pardus-flatpak-gui/ui/actionwindow.glade" update_all_builder = Gtk.Builder.new_from_file(update_all_gui_file) update_all_builder.connect_signals(self) except GLib.GError: print(_("Error reading GUI file: ") + update_all_gui_file) raise self.UpdateAllCancellation = Gio.Cancellable.new() self.UpdateAllWindow = update_all_builder.get_object("ActionWindow") self.UpdateAllWindow.set_application(application) self.UpdateAllWindow.set_title(_("Updating All")) self.UpdateAllWindow.show() self.UpdateAllButtonCancel = update_all_builder.get_object("ActionButtonCancel") self.UpdateAllButtonCancel.set_sensitive(True) self.UpdateAllProgressBar = update_all_builder.get_object( "ActionProgressBar") self.ProgressBarValue = int( self.UpdateAllProgressBar.get_fraction() * 100) self.UpdateAllLabel = update_all_builder.get_object("ActionLabel") self.UpdateAllTextBuffer = update_all_builder.get_object( "ActionTextBuffer") self.UpdateAllTextBuffer.set_text("\0", -1) self.StatusText = _("Updating...") self.UpdateAllLabel.set_text(self.StatusText) self.UpdateAllTextBuffer.set_text(self.StatusText) self.handler_id = self.FlatpakTransaction.connect( "new-operation", self.update_all_progress_callback) self.handler_id_2 = self.FlatpakTransaction.connect( "operation-done", self.update_all_progress_callback_done) self.handler_id_error = self.FlatpakTransaction.connect( "operation-error", self.update_all_progress_callback_error) self.UpdateAllThread = threading.Thread( target=self.update_all, args=()) self.UpdateAllThread.start() GLib.threads_init()
def __init__(self, application): self.Application = application try: main_gui_file = "/usr/share/pardus/pardus-flatpak-gui/ui/mainwindow.glade" main_builder = Gtk.Builder.new_from_file(main_gui_file) main_builder.connect_signals(self) except GLib.GError: print(_("Error reading GUI file: ") + main_gui_file) raise try: about_gui_file = "/usr/share/pardus/pardus-flatpak-gui/ui/aboutdialog.glade" about_builder = Gtk.Builder.new_from_file(about_gui_file) about_builder.connect_signals(self) except GLib.GError: print(_("Error reading About dialog GUI file: ") + about_gui_file) raise try: messages_gui_file = "/usr/share/pardus/pardus-flatpak-gui/ui/messagedialogs.glade" messages_builder = Gtk.Builder.new_from_file(messages_gui_file) messages_builder.connect_signals(self) except GLib.GError: print( _("Error reading message dialogs GUI file: ") + messages_gui_file) raise self.FlatpakInstallation = Flatpak.Installation.new_system() self.InstalledRefsList = self.FlatpakInstallation.list_installed_refs() self.FlatHubRefsList = self.FlatpakInstallation.list_remote_refs_sync( "flathub", Gio.Cancellable.new()) self.NonInstalledRefsList = [] for item in self.FlatHubRefsList: self.NonInstalledRefsList.append(item) for item_2 in self.InstalledRefsList: if item.get_name() == item_2.get_name() and \ item.get_arch() == item_2.get_arch() and \ item.get_branch() == item_2.get_branch(): if len(self.NonInstalledRefsList) != 0: self.NonInstalledRefsList.pop( len(self.NonInstalledRefsList) - 1) else: self.NonInstalledRefsList = [] self.AllRefsList = self.InstalledRefsList + self.NonInstalledRefsList self.ListStoreMain = main_builder.get_object("ListStoreMain") self.MessageDialogError = messages_builder.get_object( "MessageDialogError") self.MessageDialogError.set_title(_("Pardus Flatpak GUI Error Dialog")) self.MessageDialogQuestion = messages_builder.get_object( "MessageDialogQuestion") self.MessageDialogQuestion.set_title( _("Pardus Flatpak GUI Question Dialog")) # Debug print()'s: # print("self.FlatHubRefsList:", len(self.FlatHubRefsList)) # print("self.InstalledRefsList:", len(self.InstalledRefsList)) # print("self.NonInstalledRefsList:", len(self.NonInstalledRefsList)) # print("self.AllRefsList:", len(self.AllRefsList)) for item in self.AllRefsList: if item.get_kind() == Flatpak.RefKind.APP and \ item.get_arch() == Flatpak.get_default_arch(): if isinstance(item, Flatpak.RemoteRef): item_is_installed = False elif isinstance(item, Flatpak.InstalledRef): item_is_installed = True else: item_is_installed = None real_name = item.get_name() arch = item.get_arch() branch = item.get_branch() installed_size = item.get_installed_size() installed_size_mib = installed_size / 1048576 installed_size_mib_str = f"{installed_size_mib:.2f}" + " MiB" if not item_is_installed: if item in self.FlatHubRefsList: remote_name = "FlatHub" else: remote_name = "" download_size = item.get_download_size() download_size_mib = download_size / 1048576 download_size_mib_str = f"{download_size_mib:.2f}" + " MiB" name = "" elif item_is_installed: remote_name = item.get_origin() if remote_name == "flathub": remote_name = "FlatHub" download_size_mib_str = "" name = item.get_appdata_name() else: remote_name = "" download_size_mib_str = "" name = "" self.MessageDialogError.set_markup( _("<big><b>Invalid Flatpak Reference Error</b></big>")) self.MessageDialogError.format_secondary_text( _("Invalid Flatpak reference is: ") + "app/" + real_name + "/" + arch + "/" + branch) self.MessageDialogError.run() self.MessageDialogError.hide() if item_is_installed is not None: self.ListStoreMain.append([ real_name, arch, branch, remote_name, installed_size_mib_str, download_size_mib_str, name ]) else: continue self.HeaderBarMain = main_builder.get_object("HeaderBarMain") self.HeaderBarMain.set_title(_("Pardus Flatpak GUI")) self.HeaderBarMain.set_subtitle( _("Manage Flatpak softwares via GUI on Pardus")) self.RunMenuItem = main_builder.get_object("RunMenuItem") self.RunMenuItem.set_label(_("_Run")) self.InfoMenuItem = main_builder.get_object("InfoMenuItem") self.InfoMenuItem.set_label(_("_Info")) self.UninstallMenuItem = main_builder.get_object("UninstallMenuItem") self.UninstallMenuItem.set_label(_("_Uninstall")) self.InstallMenuItem = main_builder.get_object("InstallMenuItem") self.InstallMenuItem.set_label(_("I_nstall")) self.ActionsMenu = main_builder.get_object("ActionsMenu") self.UpdateAllMenuItem = main_builder.get_object("UpdateAllMenuItem") self.UpdateAllMenuItem.set_label(_("_Update All")) self.AboutMenuItem = main_builder.get_object("AboutMenuItem") self.AboutMenuItem.set_label(_("_About")) self.TreeViewColumnRealName = main_builder.get_object( "TreeViewColumnRealName") self.TreeViewColumnRealName.set_title(_("Real Name")) self.TreeViewColumnArch = main_builder.get_object("TreeViewColumnArch") self.TreeViewColumnArch.set_title(_("Arch")) self.TreeViewColumnBranch = main_builder.get_object( "TreeViewColumnBranch") self.TreeViewColumnBranch.set_title(_("Branch")) self.TreeViewColumnRemoteName = main_builder.get_object( "TreeViewColumnRemoteName") self.TreeViewColumnRemoteName.set_title(_("Remote Name")) self.TreeViewColumnInstalledSize = main_builder.get_object( "TreeViewColumnInstalledSize") self.TreeViewColumnInstalledSize.set_title(_("Installed Size")) self.TreeViewColumnDownloadSize = main_builder.get_object( "TreeViewColumnDownloadSize") self.TreeViewColumnDownloadSize.set_title(_("Download Size")) self.TreeViewColumnName = main_builder.get_object("TreeViewColumnName") self.TreeViewColumnName.set_title(_("Name")) self.TreeViewMain = main_builder.get_object("TreeViewMain") self.TreeSelectionMain = main_builder.get_object("TreeSelectionMain") self.SearchEntryMain = main_builder.get_object("SearchEntryMain") self.SearchEntryMain.set_placeholder_text(_("Click here for search")) self.SearchFilter = main_builder.get_object("SearchFilter") self.SearchFilter.set_visible_func(self.search_filter_function) self.SortModel = main_builder.get_object("SortModel") self.SortModel.set_sort_func(0, self.sorting_compare_function, (self.TreeViewColumnRealName, 0)) self.SortModel.set_sort_func(1, self.sorting_compare_function, (self.TreeViewColumnArch, 1)) self.SortModel.set_sort_func(2, self.sorting_compare_function, (self.TreeViewColumnBranch, 2)) self.SortModel.set_sort_func(3, self.sorting_compare_function, (self.TreeViewColumnRemoteName, 3)) self.SortModel.set_sort_func(4, self.sorting_float_compare_function, (self.TreeViewColumnInstalledSize, 4)) self.SortModel.set_sort_func(5, self.sorting_float_compare_function, (self.TreeViewColumnDownloadSize, 5)) self.SortModel.set_sort_func(6, self.sorting_compare_function, (self.TreeViewColumnName, 6)) self.HeaderBarShowButton = main_builder.get_object( "HeaderBarShowButton") self.HeaderBarShowButton.set_label(_("Show Installed Apps")) self.AboutDialog = about_builder.get_object("AboutDialog") self.AboutDialog.set_comments(_("Flatpak GUI for Pardus")) self.AboutDialog.set_copyright(_("Copyright (C) 2020 Erdem Ersoy")) self.AboutDialog.set_program_name(_("Pardus Flatpak GUI")) self.AboutDialog.set_version(Version.getVersion()) self.AboutDialog.set_website_label(_("Pardus Flatpak GUI Web Site")) self.MainWindow = main_builder.get_object("MainWindow") self.MainWindow.set_application(application) self.MainWindow.show()