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 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 get_kde_scaling_factor():
"""Return the widgets scaling factor on KDE."""
scaling_factor = None
was_found = False
try:
with open(KDE_CONFIG_FILE, 'r') as kde_obj:
data = kde_obj.readlines()
for line in data:
line = list(map(lambda x: x.strip(), line.split("=")))
if len(line) == 1:
was_found = match(r'\[Containments\]\[[0-9]+\]\[General\]',
line[0])
if len(line) > 1 and was_found and line[0].lower() == "iconsize":
scaling_factor = int(line[1])
break
if scaling_factor:
Logger.debug("Scaling Factor/KDE: {}".format(scaling_factor))
return scaling_factor
except (FileNotFoundError, KeyError) as kde_error:
Logger.debug("Scaling Factor/KDE not detected.")
Logger.error(kde_error)
return None
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 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 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 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 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 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 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 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 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 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 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 icon_size(self):
"""Return the icon size in the config file."""
icon_size = None
if self.icons:
icon_size = self.icons.get("size")
Logger.debug("Config/Icon Size: {}".format(icon_size))
if icon_size not in ICONS_SIZE:
Logger.warning("Config/Icon Size: Incorrect.")
Logger.debug("Config/Icon Size: Detected icon "
"size will be used.")
return icon_size
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 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 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 _read(self):
"""Read the config file."""
if path.isfile(CONFIG_FILE):
Logger.debug("Reading config file: {}".format(CONFIG_FILE))
with open(CONFIG_FILE, 'r') as data:
try:
config = load(data)
for key, value in config.items():
setattr(self, "_" + key, value)
except ValueError:
Logger.warning("The config file is "
"not a valid json file.")
else:
Logger.debug("Config file: Not found.")
def reinstall(self):
"""Overwrite the reinstall function, and remove the whole dir."""
done = False
for icon_path in self.icons_path:
icon_path = str(icon_path)
if path.isdir(icon_path):
rmtree(icon_path)
Logger.debug("Qt Application: Reverting {} is done.".format(
self.name))
done = True
if not done:
Logger.debug("Qt Application: Reverting {} is not done.".format(
self.name))
self.success = done
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 extract(self, icon_path):
"""Extract the zip file in /tmp directory."""
if path.exists(self.tmp_path):
rmtree(self.tmp_path)
makedirs(self.tmp_path, exist_ok=True)
Logger.debug("Zip Application: Extracting of {} started".format(
self.binary))
with ZipFile(path.join(str(icon_path), self.binary)) as zip_object:
zip_object.extractall(self.tmp_path)
Logger.debug("Zip Application: Extracting is done.")
def pack(self, icon_path):
"""Recreate the zip file from the tmp directory."""
zip_file = path.join(str(icon_path), self.binary)
if path.isfile(zip_file):
Logger.debug("Zip Application: Removing old binary file {}".format(
zip_file))
remove(zip_file)
make_archive(zip_file.replace(".zip", ""), 'zip', self.tmp_path)
Logger.debug("Zip Application: Creating a new zip archive.")
if path.exists(self.tmp_path):
rmtree(self.tmp_path)
def icon_size():
"""Return the icon size in the config file."""
if JSONConfig._icon_size is None:
json = JSONConfig.get_default()
icons = json.get("icons")
if icons:
icon_size = icons.get("size")
Logger.debug("Config/Icon Size: {}".format(icon_size))
if icon_size not in ICONS_SIZE:
Logger.warning("Config/Icon Size: Incorrect.")
Logger.debug(
"Config/Icon Size: Detected icon size will be used.")
JSONConfig._icon_size = icon_size
return JSONConfig._icon_size
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
def create(self, filename):
"""Backup functions."""
from src.app import App
if not App.get("backup_ignore"):
if not self.backup_dir:
self.create_backup_dir()
backup_file = path.join(self.backup_dir, path.basename(filename))
if path.exists(filename):
Logger.debug("Backup file: {0} to: {1}".format(
filename, backup_file))
copy_file(filename, backup_file, True)
mchown(backup_file)