def conversion_tool():
"""Return conversion tool set in the config file."""
if not JSONConfig._conversion_tool:
conversion_tool = JSONConfig.get_default().get("conversion-tool")
Logger.debug("Config/Conversion Tool: {}".format(conversion_tool))
JSONConfig._conversion_tool = conversion_tool
return JSONConfig._conversion_tool
def icon_size():
"""Return Icon size set by args --size."""
if ArgumentsConfig._icon_size is None:
icon_size = ArgumentsConfig.args().size
Logger.debug("Arguments/Icon Size: {}".format(icon_size))
ArgumentsConfig._icon_size = icon_size
return ArgumentsConfig._icon_size
def set_value(self, key, value):
"""Set a value in the resources list using a key."""
try:
self._resources[int(key)] = value
except KeyError:
Logger.warning("The key {0} dosen't seem to"
" be found on {1}".format(key, self._filename))
def _read(self):
"""
Read the json file and parse it.
"""
from src.app import App
do_later = ["app_path", "icons_path", "icons"]
try:
with open(self._db_file, 'r') as db_obj:
data = json.load(db_obj)
for key, value in data.items():
if key not in do_later:
setattr(self, key, value)
except (FileNotFoundError, ValueError, KeyError):
Logger.error("Application file is broken: {}".format(
self._db_file))
self._parse_paths(data["app_path"], "app_path")
self._parse_paths(data["icons_path"], "icons_path")
self._parse_icons(data["icons"])
if len(App.get("only")) == 1 and App.path():
self.app_path.append(App.path())
found = self.icons and self.app_path
if self.force_create_folder and found:
for icon_path in self.icons_path:
create_dir(str(icon_path))
self.dont_install = False
else:
self.dont_install = not (found and self.icons_path)
# NWJS special case
if self.get_type() == "nwjs" and not self.dont_install:
self.dont_install = not App.get("nwjs")
def nwjs(self):
"""Return nwjs sdk path."""
nwjs = self._nwjs
if nwjs and path.exists(nwjs):
Logger.debug("Config/NWJS SDK: {}".format(nwjs))
return nwjs
return None
def install_icon(self, icon, icon_path):
"""Install the icon."""
pngbytes = get_pngbytes(icon)
if pngbytes:
self.set_icon(icon.original, icon_path, pngbytes, True)
else:
Logger.error("PNG file was not found.")
def backup_ignore():
"""Return a boolean, ignore backup or not."""
if JSONConfig._backup_ignore is None:
backup_ignore = JSONConfig.get_default().get("backup-ignore", False)
Logger.debug("Config/Backup Ignore: {}".format(str(backup_ignore)))
JSONConfig._backup_ignore = backup_ignore
return JSONConfig._backup_ignore
def pack(self, icon_path):
"""Recreate the zip file from the tmp directory."""
from src.app import App
nwjs_sdk = App.get("nwjs")
if nwjs_sdk:
binary_file = "/tmp/{0}".format(self.binary)
Logger.debug("NWJS Application: Creating new archive {}".format(
self.binary))
make_archive(binary_file, "zip", self.tmp_path)
move(binary_file + ".zip", binary_file + ".nw")
local_binary_file = path.join(nwjs_sdk, self.binary)
move(binary_file + ".nw", local_binary_file + ".nw")
Logger.debug("NWJS Application: Creating executable file.")
execute(["cat which nw " + self.binary + ".nw > " + self.binary],
True, True, nwjs_sdk)
remove(local_binary_file + ".nw")
move(local_binary_file, path.join(str(icon_path), self.binary))
execute(["chmod", "+x", path.join(str(icon_path), self.binary)])
rmtree(self.tmp_path)
def _validate_with_callback(self, key, callback):
module = import_module("src.path")
if hasattr(module, callback):
method = getattr(module, callback)
self.path = get_exact_folder(key, self.path, method)
Logger.debug("Path with condition: {} {}".format(
callback, self.path))
def select(self):
"""Show a select option for the backup of each application."""
backup_folders = self.get_backup_folders()
total = len(backup_folders)
if total != 0:
backup_folders.sort()
self._display_choices(backup_folders)
print(_("(Q)uit to cancel"))
has_chosen = False
stopped = False
while not has_chosen and not stopped:
try:
selected = input("Select a restore date : ")
if selected in ["q", "quit", "exit"]:
stopped = True
selected = int(selected)
if 1 <= selected <= total:
has_chosen = True
self._exists = True
self._selected_backup = backup_folders[selected - 1]
except ValueError:
pass
except KeyboardInterrupt:
exit()
if stopped:
Logger.debug("The user stopped the "
"reversion for {}".format(self.app.name))
else:
Logger.debug("No backup folder found for "
"the application {0}".format(self.app.name))
def __getattr__(self, name):
if hasattr(self.parser, name):
return getattr(self.parser, name)
elif hasattr(self, name):
return getattr(self, name)
Logger.warning("Couldn't find attribute {}".format(name))
return None
def install_icon(self, icon, icon_path):
"""Install the icon."""
png_bytes = get_pngbytes(icon)
if png_bytes:
icon = ElectronApplication.get_real_path(icon.original)
self.set_icon(icon, icon_path, png_bytes, True)
else:
Logger.error("PNG file was not found.")
def only(self):
"""Return list of apps to be fixed."""
only = self._args.only
if only:
only = only.lower().strip()
Logger.debug("Arguments/Only: {}".format(only))
return only.split(",")
return []
def icon_size():
"""Return the icon size."""
if DESKTOP_ENV in ("pantheon", "xfce"):
icon_size = 24
else:
icon_size = 22
Logger.debug("System/Icon Size: {}".format(icon_size))
return icon_size
def conversion_tool():
"""Return conversion tool set by --conversion-tool."""
if not ArgumentsConfig._conversion_tool:
conversion_tool = ArgumentsConfig.args().conversion_tool
Logger.debug(
"Arguments/Conversion Tool: {}".format(conversion_tool))
ArgumentsConfig._conversion_tool = conversion_tool
return ArgumentsConfig._conversion_tool
def nwjs():
"""Return nwjs sdk path."""
if not JSONConfig._nwjs:
nwjs = JSONConfig.get_default().get("nwjs")
if nwjs and path.exists(nwjs):
JSONConfig._nwjs = nwjs
Logger.debug("Config/NWJS SDK: {}".format(nwjs))
return JSONConfig._nwjs
def get_value(self, key):
"""Get the value of a specific key in the resources list."""
try:
return self._resources.get(int(key))
except KeyError:
Logger.warning("The key {0} dosen't seem to"
" be found on {1}".format(key, self._filename))
return None
def only():
"""Return list of apps to be fixed."""
if ArgumentsConfig._only is None:
only = ArgumentsConfig.args().only
if only:
only = only.lower().strip()
Logger.debug("Arguments/Only: {}".format(only))
ArgumentsConfig._only = only.split(",")
return ArgumentsConfig._only
def blacklist():
"""Return a list of blacklist apps."""
if not JSONConfig._blacklist:
blacklist = JSONConfig.get_default().get("blacklist", [])
if blacklist:
Logger.debug(
"Config/Blacklist: {}".format(",".join(blacklist)))
JSONConfig._blacklist = blacklist
return JSONConfig._blacklist
def icon_size():
"""Return the icon size."""
if SystemConfig._icon_size is None:
if DESKTOP_ENV in ("pantheon", "xfce"):
icon_size = 24
else:
icon_size = 22
Logger.debug("System/Icon Size: {}".format(icon_size))
SystemConfig._icon_size = icon_size
return SystemConfig._icon_size
def symlink_file(source, link_name):
"""Symlink a file, remove the dest file if already exists."""
try:
symlink(source, link_name)
mchown(link_name)
except FileExistsError:
remove(link_name)
symlink_file(source, link_name)
except FileNotFoundError:
Logger.warning("File not found: {0}".format(source))
def revert_icon(self, icon, icon_path):
"""Revert to the original icon."""
asar_icon_path = ElectronApplication.get_real_path(icon.original)
backup_file = "|".join(asar_icon_path.split("/"))
png_bytes = self.get_backup_file(backup_file)
if png_bytes:
self.set_icon(icon.original, icon_path, png_bytes)
else:
Logger.error("Backup file of {0} was not found".format(self.name))
def extract(self, icon_path):
"""Extract the zip file in /tmp directory."""
if path.exists(self.tmp_path):
rmtree(self.tmp_path)
Logger.debug("NWJS Application: Extracting of {}".format(self.binary))
execute([
"unzip",
path.join(str(icon_path), self.binary), "-d", self.tmp_path
])
def get_gnome_scaling_factor():
"""Return gnome scaling factor."""
source = Gio.SettingsSchemaSource.get_default()
if source.lookup("org.gnome.desktop.interface", True):
gsettings = Gio.Settings.new("org.gnome.desktop.interface")
scaling_factor = gsettings.get_uint('scaling-factor') + 1
Logger.debug("Scaling Factor/GNOME: {}".format(scaling_factor))
return scaling_factor
else:
Logger.debug("Scaling Factor/Gnome not detected.")
return 1
def theme():
"""Return a theme object."""
theme_name = Gtk.Settings.get_default().get_property(
"gtk-icon-theme-name")
theme = None
if theme_name:
Logger.debug("System/Theme: {}".format(theme_name))
theme = Theme(theme_name)
else:
Logger.error("System/Theme: Not detected.")
return theme
def create_dir(directory):
"""
Create a directory and fix folder permissions.
Args :
folder (str): folder path
"""
if not path.exists(directory):
Logger.debug("Creating directory: {}".format(directory))
makedirs(directory, exist_ok=True)
mchown(directory)
def theme():
"""Return a theme object."""
if SystemConfig._theme is None:
source = Gio.SettingsSchemaSource.get_default()
if source.lookup("org.gnome.desktop.interface", True):
gsettings = Gio.Settings.new("org.gnome.desktop.interface")
theme_name = gsettings.get_string("icon-theme")
SystemConfig._theme = Theme(theme_name)
Logger.debug("System/Theme: {}".format(theme_name))
else:
Logger.error("System/Theme: Not detected.")
return SystemConfig._theme
def scaling_factor():
"""
Returns the scaling factor.
"""
if not App._scaling_factor:
scaling_factor = App.get("scaling_factor")
if scaling_factor and scaling_factor > 1:
# Change icon size by * it by the scaling factor
App._icon_size = round(App.icon_size() * scaling_factor, 0)
Logger.debug("Icon Size: {}".format(App._icon_size))
App._scaling_factor = scaling_factor
return App._scaling_factor
def detect_de(de_list):
"""Detect the desktop environment, used to choose the proper icons size."""
try:
desktop_env = [environ.get("DESKTOP_SESSION").lower(),
environ.get("XDG_CURRENT_DESKTOP").lower()]
except AttributeError:
desktop_env = []
for desktop in desktop_env:
if desktop in de_list:
Logger.debug("DE: {0}".format(desktop.title()))
return desktop
Logger.debug("DE not detected.")
return "other"
def get_cinnamon_scaling_factor():
"""Return Cinnamon desktop scaling factor."""
source = Gio.SettingsSchemaSource.get_default()
if source.lookup("org.cinnamon.desktop.interface", True):
gsettings = Gio.Settings.new("org.cinnamon.desktop.interface")
scaling_factor = gsettings.get_uint('scaling-factor')
if scaling_factor == 0:
# Cinnamon does have an auto scaling feature which we can't use
scaling_factor = 1
Logger.debug("Scaling Factor/Cinnamon: {}".format(scaling_factor))
return scaling_factor
else:
Logger.debug("Scaling Factor/Cinnamon not detected")
return 1
