mirror of
https://github.com/ClovertaTheTrilobita/niri-dots.git
synced 2026-04-01 22:04:53 +00:00
882 lines
26 KiB
Python
Executable file
882 lines
26 KiB
Python
Executable file
#!/usr/bin/python3
|
|
|
|
# Standard library modules
|
|
import sys
|
|
import os
|
|
import re
|
|
import json
|
|
import argparse
|
|
import urllib.request as request
|
|
from urllib.error import HTTPError, URLError
|
|
from argparse import ArgumentParser, RawTextHelpFormatter
|
|
from os.path import dirname, basename, isdir, exists
|
|
from shutil import which, rmtree, copytree, copyfile
|
|
try:
|
|
from PIL import Image
|
|
except:
|
|
has_PIL = False
|
|
else:
|
|
has_PIL = True
|
|
|
|
# Local Matter modules
|
|
from utils import *
|
|
from svg2png import inkscape_convert_svg2png, magick_convert_svg2png
|
|
|
|
# Configuration constants
|
|
|
|
MIN_PYTHON_VERSION = (3, 6) # Mainly for f-strings
|
|
|
|
THEME_NAME = "Matter"
|
|
THEME_DESCRIPTION = (
|
|
"Matter is a minimalist grub theme originally inspired by material design 2.\n"
|
|
"Run this script without arguments for next steps on installing Matter."
|
|
)
|
|
|
|
|
|
|
|
if exists("/boot/grub"):
|
|
BOOT_GRUB_PATH = "/boot/grub"
|
|
elif exists("/boot/grub2"):
|
|
BOOT_GRUB_PATH = "/boot/grub2"
|
|
else:
|
|
error("Could not find your grub's boot path (tried /boot/grub and /boot/grub2)")
|
|
|
|
INSTALLER_ABSPATH = os.path.abspath(__file__)
|
|
INSTALLER_NAME = basename(INSTALLER_ABSPATH)
|
|
INSTALLER_DIR = dirname(INSTALLER_ABSPATH)
|
|
INSTALLATION_SOURCE_DIR = f"{INSTALLER_DIR}/{THEME_NAME}"
|
|
INSTALLATION_TARGET_DIR = f"{BOOT_GRUB_PATH}/themes/{THEME_NAME}"
|
|
|
|
THEME_DEFAULT_HIGHLIGHT = "pink"
|
|
THEME_DEFAULT_FOREGROUND = "white"
|
|
THEME_DEFAULT_BACKGROUND = "bluegrey-900"
|
|
THEME_DEFAULT_FONT_NAME = "Josefin Sans Regular"
|
|
THEME_DEFAULT_FONT = THEME_DEFAULT_FONT_NAME.replace(" ", "_")
|
|
THEME_DEFAULT_FONT_SIZE = 32
|
|
|
|
GRUB_DEFAULTS_PATH = "/etc/default/grub"
|
|
GRUB_SCRIPTS_PATH = "/etc/grub.d"
|
|
GRUB_CFG_PATH = f"{BOOT_GRUB_PATH}/grub.cfg"
|
|
GRUB_MKCONFIG_PATH = which("grub-mkconfig") or which("grub2-mkconfig")
|
|
if GRUB_MKCONFIG_PATH is None:
|
|
error("Could not find grub-mkconfig command file (grub2-mkconfig neither)")
|
|
|
|
|
|
THEME_TEMPLATE_PATH = f"{INSTALLER_DIR}/theme.txt.template"
|
|
GRUB_DEFAULTS_TEMPLATE_PATH = f"{INSTALLER_DIR}/grub.template"
|
|
HOOKCHECK_TEMPLATE_PATH = f"{INSTALLER_DIR}/hookcheck.py.template"
|
|
|
|
THEME_OVERRIDES_TITLE = f"{THEME_NAME} Theme Overrides"
|
|
BEGIN_THEME_OVERRIDES = f"### BEGIN {THEME_OVERRIDES_TITLE}"
|
|
END_THEME_OVERRIDES = f"### END {THEME_OVERRIDES_TITLE}"
|
|
|
|
ICON_SVG_PATHF = f"{INSTALLER_DIR}/icons/{{}}.svg"
|
|
ICON_PNG_PATHF = f"{INSTALLATION_SOURCE_DIR}/icons/{{}}.png"
|
|
|
|
BACKGROUND_TMP_PATHF = f"{INSTALLER_DIR}/bg/{{}}.tmp"
|
|
BACKGROUND_PNG_PATHF = f"{INSTALLER_DIR}/bg/{{}}.png"
|
|
|
|
CONFIG_FILE_PATH = f"{INSTALLER_DIR}/config.json"
|
|
|
|
PALETTE = {
|
|
"red": "f44336",
|
|
"pink": "e91e63",
|
|
"purple": "9c27b0",
|
|
"deeppurple": "673ab7",
|
|
"indigo": "3f51b5",
|
|
"blue": "2196f3",
|
|
"lightblue": "03a9f4",
|
|
"cyan": "00bcd4",
|
|
"teal": "009688",
|
|
"green": "4caf50",
|
|
"lightgreen": "8bc34a",
|
|
"lime": "cddc39",
|
|
"yellow": "ffeb3b",
|
|
"amber": "ffc107",
|
|
"orange": "ff9800",
|
|
"deeporange": "ff5722",
|
|
"brown": "795548",
|
|
"grey": "9e9e9e",
|
|
"bluegrey": "607d8b",
|
|
"white": "ffffff",
|
|
"black": "000000",
|
|
# Custom default colors
|
|
"white-350": "9E9E9E",
|
|
"bluegrey-900": "263238",
|
|
}
|
|
AVAILABLE_COLORS = list(PALETTE.keys())
|
|
|
|
MDI_CDN = "https://raw.githubusercontent.com/Templarian/MaterialDesign-SVG/master/svg/"
|
|
|
|
# Global user arguments set in main()
|
|
user_args: argparse.Namespace
|
|
|
|
# Utils
|
|
|
|
def check_python_version():
|
|
installed = (sys.version_info.major, sys.version_info.minor)
|
|
required = MIN_PYTHON_VERSION
|
|
if installed < required:
|
|
error(f"Python {required[0]}.{required[1]} or later required")
|
|
|
|
|
|
def check_root_or_prompt():
|
|
if os.geteuid() != 0:
|
|
info("Request root access")
|
|
exit_code = sh("sudo -v")
|
|
if exit_code != 0:
|
|
error("Could not verify root access, you could try with sudo")
|
|
# Relaunch the program with sudo
|
|
args = " ".join(sys.argv[1:])
|
|
child_exit_code = sh(f"sudo {INSTALLER_DIR}/{INSTALLER_NAME} {args}")
|
|
exit(child_exit_code) # Propagate exit code
|
|
|
|
|
|
def delete_dir(directory):
|
|
if isdir(directory):
|
|
rmtree(directory)
|
|
|
|
|
|
def read_cleaned_grub_defaults():
|
|
# Read previous defaults
|
|
with open(GRUB_DEFAULTS_PATH, "r", newline="") as f:
|
|
grub_defaults = f.read()
|
|
|
|
# Remove previous theme defaults
|
|
cleaned_grub_defaults = re.sub(
|
|
f"\n*{BEGIN_THEME_OVERRIDES}.*{END_THEME_OVERRIDES}\n*",
|
|
"",
|
|
grub_defaults,
|
|
flags=re.DOTALL,
|
|
)
|
|
return cleaned_grub_defaults
|
|
|
|
|
|
def read_cleaned_grub_mkconfig():
|
|
# Read previous defaults
|
|
with open(GRUB_MKCONFIG_PATH, "r", newline="") as f:
|
|
grub_mkconfig = f.read()
|
|
|
|
# Remove previous theme defaults
|
|
cleaned_grub_mkconfig = re.sub(
|
|
f"\n*{BEGIN_THEME_OVERRIDES}.*{END_THEME_OVERRIDES}\n*",
|
|
"",
|
|
grub_mkconfig,
|
|
flags=re.DOTALL,
|
|
)
|
|
return cleaned_grub_mkconfig
|
|
|
|
|
|
def download_icon(icon_name):
|
|
info(f"Download {icon_name}.svg")
|
|
url = f"{MDI_CDN}{icon_name}.svg"
|
|
try:
|
|
with request.urlopen(url) as f:
|
|
response = f.read()
|
|
except HTTPError as err: # A subclass of URLError
|
|
error(f"Couldn't get icon {icon_name} ({err.reason})", f"At URL {err.geturl()}")
|
|
except URLError as err:
|
|
error(f"Couldn't get icon {icon_name} ({err.reason})")
|
|
svg_path = ICON_SVG_PATHF.format(icon_name)
|
|
with open(svg_path, "wb") as f:
|
|
f.write(response)
|
|
return svg_path
|
|
|
|
|
|
def download_background(background_path):
|
|
if not has_PIL:
|
|
error("PIL not detected, cannot download background")
|
|
info(f"Downloading background image")
|
|
|
|
url = f"{background_path}"
|
|
try:
|
|
with request.urlopen(url) as f:
|
|
response = f.read()
|
|
except HTTPError as err: # A subclass of URLError
|
|
error(f"Couldn't get background image ({err.reason})", f"At URL {err.geturl()}")
|
|
except URLError as err:
|
|
error(f"Couldn't get background image ({err.reason})")
|
|
bg_path = BACKGROUND_TMP_PATHF.format('background_image')
|
|
conv_path = BACKGROUND_PNG_PATHF.format('background_image')
|
|
with open(bg_path, "wb") as f:
|
|
f.write(response)
|
|
im = Image.open(bg_path)
|
|
im.save(conv_path)
|
|
return conv_path
|
|
|
|
|
|
|
|
def get_converted_icons():
|
|
return [
|
|
filename[:-4] # Remove .png
|
|
for filename in os.listdir(f"{INSTALLATION_SOURCE_DIR}/icons/")
|
|
if filename.endswith(".png")
|
|
]
|
|
|
|
|
|
def is_icon_downloaded(icon_name):
|
|
svg_path = ICON_SVG_PATHF.format(icon_name)
|
|
return exists(svg_path)
|
|
|
|
|
|
def convert_icon_svg2png(icon_name, whisper=False):
|
|
if not has_command("inkscape"):
|
|
if not has_command("convert"):
|
|
error(
|
|
"Stop. Both `inkscape` and `convert` command from imagemagick were not found",
|
|
"Consider installing `inkscape` for the best results",
|
|
)
|
|
else:
|
|
command = "convert"
|
|
else:
|
|
command = "inkscape"
|
|
|
|
color = (
|
|
parse_color(user_args.iconcolor)
|
|
if user_args.iconcolor
|
|
else parse_color(user_args.foreground)
|
|
)
|
|
src_path = ICON_SVG_PATHF.format(icon_name)
|
|
dst_path = ICON_PNG_PATHF.format(icon_name)
|
|
|
|
if command == "convert":
|
|
warning("Resulting icons could look a bit off, consider installing inkscape")
|
|
converter = magick_convert_svg2png
|
|
elif command == "inkscape":
|
|
converter = inkscape_convert_svg2png
|
|
|
|
exit_code = converter(color, src_path, dst_path, whisper=whisper)
|
|
if exit_code != 0:
|
|
error(f"Stop. The `{command}` command returned an error")
|
|
|
|
|
|
def get_available_fonts():
|
|
"Returns the fonts present in /fonts"
|
|
return [
|
|
filename[:-4] # Remove .ttf
|
|
for filename in os.listdir(f"{INSTALLER_DIR}/fonts/")
|
|
if filename.endswith(".ttf")
|
|
]
|
|
|
|
|
|
def parse_color(color_string):
|
|
if color_string in AVAILABLE_COLORS:
|
|
color = PALETTE[color_string]
|
|
elif re.match(r"[0-9A-Fa-f]{6}", color_string) is not None:
|
|
color = color_string
|
|
else:
|
|
error(
|
|
f"Invalid color parsed from {color_string}",
|
|
f"Color must be an hex code like C00FFE or one of: {AVAILABLE_COLORS}",
|
|
)
|
|
return f"#{color}"
|
|
|
|
|
|
def check_icon_converted(icon):
|
|
available_icons = get_converted_icons()
|
|
if icon not in available_icons + ["_"]:
|
|
error(f"Invalid icon name: {icon}", f"Icons present are: {available_icons}")
|
|
return icon
|
|
|
|
|
|
def parse_font(font):
|
|
"""From a given --font check if available and return its font name
|
|
e.g. Open_Sans_Regular to Open Sans Regular"""
|
|
available_fonts = get_available_fonts()
|
|
if font not in available_fonts:
|
|
error(
|
|
f"Invalid font name: {font}", f"Available font names: {available_fonts}",
|
|
)
|
|
return font.replace("_", " ")
|
|
|
|
|
|
# Procedures
|
|
|
|
|
|
def clean_install_dir():
|
|
info("Clean install directory")
|
|
if isdir(INSTALLATION_TARGET_DIR):
|
|
rmtree(INSTALLATION_TARGET_DIR)
|
|
|
|
|
|
def prepare_source_dir():
|
|
info("Build theme from user preferences")
|
|
# Get user color preferences
|
|
highlight = parse_color(user_args.highlight)
|
|
foreground = parse_color(user_args.foreground)
|
|
background = parse_color(
|
|
THEME_DEFAULT_BACKGROUND
|
|
if user_args.background is None
|
|
else user_args.background
|
|
)
|
|
image = (
|
|
user_args.image
|
|
if user_args.downloadbackground is None
|
|
else download_background(user_args.downloadbackground)
|
|
)
|
|
fontkey = user_args.font
|
|
fontfile = user_args.fontfile
|
|
fontname = user_args.fontname
|
|
fontsize = user_args.fontsize
|
|
icons = user_args.icons
|
|
|
|
# Image checks
|
|
if image:
|
|
if not exists(image):
|
|
error(f"{image} does not exist")
|
|
if os.path.splitext(image)[1] not in (".png", ".jpg", ".jpeg", ".tga"):
|
|
error("Background image must be one of .png, .jpg, .jpeg or .tga formats.")
|
|
image_name = basename(image)
|
|
copyfile(image, f"{INSTALLATION_SOURCE_DIR}/{image_name}")
|
|
if user_args.background:
|
|
warning(
|
|
f"Both --background and --image arguments specified. Background color {background} will be ignored."
|
|
)
|
|
else:
|
|
image_name = "background.png"
|
|
|
|
# Icon checks
|
|
# Get entries from grub.cfg
|
|
entries = get_entry_names()
|
|
# Do icon count match grub entry count?
|
|
if len(icons) != len(entries):
|
|
error(
|
|
f"You must specify {len(entries)} icons ({len(icons)} provided) for entries:",
|
|
should_exit=False,
|
|
)
|
|
for i, m in enumerate(entries):
|
|
print(f"{i + 1}. {m['entryname']}")
|
|
exit(1)
|
|
|
|
# Font checks
|
|
# grub-mkfont present
|
|
grub_mkfont = which("grub-mkfont") or which("grub2-mkfont")
|
|
if grub_mkfont is None:
|
|
error(f"grub-mkfont command not found in your system (grub2-mkfont neither)")
|
|
# Valid font arguments
|
|
if fontfile is None: # User did not specify custom font file
|
|
fontfile = f"{INSTALLER_DIR}/fonts/{fontkey}.ttf"
|
|
fontname = f"{parse_font(fontkey)} {fontsize}"
|
|
elif not fontfile.endswith(".ttf"): # font file is not ttf
|
|
error(f"{fontfile} is not a .ttf file")
|
|
elif fontname is None: # User did, but did not gave its name
|
|
error(
|
|
"--fontname/-fn not specified for given font file.",
|
|
"e.g. 'Open Sans Regular'",
|
|
)
|
|
else: # User specified a custom fontfile
|
|
fontname = " ".join(fontname) # e.g. Open Sans Regular
|
|
dst_fontfile = f"{INSTALLER_DIR}/fonts/{fontname.replace(' ', '_')}.ttf" # e.g. .../Open_Sans_Regular.ttf
|
|
copyfile(fontfile, dst_fontfile)
|
|
fontfile = dst_fontfile
|
|
fontname = f"{fontname} {fontsize}" # e.g. Open Sans Regular 32
|
|
|
|
# Prepare Icons
|
|
|
|
# Download not-yet-downloaded icons
|
|
for icon in icons:
|
|
if not is_icon_downloaded(icon) and icon != "_":
|
|
download_icon(icon)
|
|
|
|
# Convert icons
|
|
info("Convert icons")
|
|
for i, icon in enumerate(icons):
|
|
if icon != "_":
|
|
if i == 0:
|
|
convert_icon_svg2png(icon)
|
|
else:
|
|
convert_icon_svg2png(icon, whisper=True)
|
|
|
|
# Prepare Font
|
|
|
|
# Generate font file
|
|
info("Build font")
|
|
stdout = shout(
|
|
f"{grub_mkfont} -o {INSTALLATION_SOURCE_DIR}/font.pf2 {fontfile} -s {fontsize}"
|
|
)
|
|
if stdout:
|
|
error(
|
|
f"{grub_mkfont} execution was not clean", f"for fontfile: {fontfile}",
|
|
)
|
|
|
|
# Prepare Theme.txt
|
|
|
|
# Parse theme template with user preferences
|
|
with open(THEME_TEMPLATE_PATH, "r", newline="") as f:
|
|
template = f.read()
|
|
|
|
context = {
|
|
"theme_name": THEME_NAME,
|
|
"highlight": highlight,
|
|
"foreground": foreground,
|
|
"background": background,
|
|
"image_name": image_name,
|
|
"fontname": fontname,
|
|
}
|
|
parsed_theme = template.format(**context)
|
|
|
|
if image:
|
|
parsed_theme = parsed_theme.replace("# desktop-image", "desktop-image")
|
|
|
|
theme_file_path = f"{INSTALLATION_SOURCE_DIR}/theme.txt"
|
|
with open(theme_file_path, "w") as f:
|
|
f.write(parsed_theme)
|
|
|
|
|
|
def prepare_target_dir():
|
|
info("Prepare installation directory")
|
|
clean_install_dir()
|
|
|
|
|
|
def copy_source_to_target():
|
|
info("Copy built theme to installation directory")
|
|
copytree(INSTALLATION_SOURCE_DIR, INSTALLATION_TARGET_DIR)
|
|
|
|
|
|
def update_grub_cfg():
|
|
info("Update grub.cfg")
|
|
update_command = (
|
|
which("update-grub") or which("grub-mkconfig") or which("grub2-mkconfig")
|
|
)
|
|
if update_command is None:
|
|
error(
|
|
f"Command for generating grub.cfg not found (tried update-grub, grub-mkconfig and grub2-mkconfig)"
|
|
)
|
|
command = f"{update_command} -o {GRUB_CFG_PATH}"
|
|
info(f"Remake grub.cfg with {command}")
|
|
sh(command)
|
|
|
|
|
|
def update_grub_defaults():
|
|
info(f"Patch {GRUB_DEFAULTS_PATH} with {THEME_OVERRIDES_TITLE}")
|
|
grub_configs = read_cleaned_grub_defaults()
|
|
|
|
# Parse grub defaults template, append parsed contents, and write back
|
|
|
|
with open(GRUB_DEFAULTS_TEMPLATE_PATH, "r", newline="") as f:
|
|
template = f.read()
|
|
|
|
context = {"installation_dir": INSTALLATION_TARGET_DIR}
|
|
parsed_extra_grub = template.format(**context)
|
|
grub_configs += (
|
|
f"\n\n{BEGIN_THEME_OVERRIDES}\n{parsed_extra_grub}\n{END_THEME_OVERRIDES}\n\n"
|
|
)
|
|
|
|
with open(GRUB_DEFAULTS_PATH, "w") as f:
|
|
f.write(grub_configs)
|
|
|
|
|
|
def clean_grub_defaults():
|
|
info(f"Clean {THEME_OVERRIDES_TITLE} from {GRUB_DEFAULTS_PATH}")
|
|
cleaned_grub_defaults = read_cleaned_grub_defaults()
|
|
with open(GRUB_DEFAULTS_PATH, "w") as f:
|
|
f.write(cleaned_grub_defaults)
|
|
|
|
|
|
def clean_grub_mkconfig():
|
|
info(f"Clean {THEME_OVERRIDES_TITLE} from {GRUB_MKCONFIG_PATH}")
|
|
cleaned_grub_mkconfig = read_cleaned_grub_mkconfig()
|
|
with open(GRUB_MKCONFIG_PATH, "w") as f:
|
|
f.write(cleaned_grub_mkconfig)
|
|
|
|
|
|
def clean_hookcheck():
|
|
info(f"Remove hookcheck script from {GRUB_SCRIPTS_PATH}")
|
|
hookcheck = f"{GRUB_SCRIPTS_PATH}/99_matter"
|
|
if exists(hookcheck):
|
|
os.remove(hookcheck)
|
|
|
|
|
|
def get_entry_names():
|
|
"Gets the entry names from grub.cfg contents"
|
|
with open(GRUB_CFG_PATH, "r", newline="") as f:
|
|
grub_cfg = f.read()
|
|
pattern = (
|
|
r"(?P<head>(?:submenu|menuentry) ?)" # menuentry or submenu
|
|
r"(?:\"|')" # " or '
|
|
r"(?P<entryname>[^\"']*)" # capture the entry name (without quotes)
|
|
r"(?:\"|')" # " or '
|
|
r"(?P<tail>[^\{]*\{)" # The rest of the entry header until a { is found
|
|
)
|
|
matchiter = re.finditer(pattern, grub_cfg)
|
|
matches = list(matchiter)
|
|
return matches
|
|
|
|
|
|
# Main procedures
|
|
|
|
|
|
def do_preinstall_hint():
|
|
info(
|
|
f"{color_string('[ ', fg='brightwhite')}"
|
|
f"{color_string(THEME_NAME, fg='brightmagenta')} "
|
|
f"{color_string('Grub Theme'.upper(), fg='lightcyan')}"
|
|
f"{color_string(' ]', fg='brightwhite')}"
|
|
)
|
|
info("Argument -i required. Which icons go to which grub entries?")
|
|
info("Your grub entries are:")
|
|
do_list_grub_cfg_entries()
|
|
info("Look for icons you like at https://materialdesignicons.com/")
|
|
info("Then install with:")
|
|
info("./matter.py -i icon-for-entry-1 icon-for-entry-2 ...")
|
|
info("Example (with 8 entries, _ means ignore):")
|
|
info("./matter.py -i ubuntu microsoft-windows folder _ _ _ _ cog")
|
|
|
|
|
|
def do_test():
|
|
info("Begin grub2-theme-preview")
|
|
warning(
|
|
"Argument --icons/-i does not have effect when testing",
|
|
"The icon names used are coming from your system's current grub.cfg",
|
|
"This is a feature that may work in the future",
|
|
)
|
|
if not has_command("grub2-theme-preview"):
|
|
error(
|
|
"You need grub2-theme-preview for testing",
|
|
"See https://github.com/hartwork/grub2-theme-preview",
|
|
)
|
|
sh(f"grub2-theme-preview {INSTALLATION_SOURCE_DIR}")
|
|
|
|
|
|
def do_install():
|
|
info(f"Begin {THEME_NAME} install")
|
|
prepare_source_dir()
|
|
check_root_or_prompt()
|
|
prepare_target_dir()
|
|
copy_source_to_target()
|
|
update_grub_defaults()
|
|
do_set_icons(patch_grubcfg=True)
|
|
install_hookcheck()
|
|
update_grub_cfg()
|
|
info(f"{THEME_NAME} successfully installed")
|
|
|
|
|
|
def do_uninstall():
|
|
info(f"Begin {THEME_NAME} uninstall")
|
|
check_root_or_prompt()
|
|
clean_grub_defaults()
|
|
clean_grub_mkconfig()
|
|
clean_hookcheck()
|
|
clean_install_dir()
|
|
update_grub_cfg()
|
|
info(f"{THEME_NAME} successfully uninstalled")
|
|
|
|
|
|
def do_list_grub_cfg_entries():
|
|
# Read current grub cfg
|
|
with open(GRUB_CFG_PATH, "r", newline="") as f:
|
|
grub_cfg = f.read()
|
|
|
|
entries = get_entry_names()
|
|
|
|
for i, m in enumerate(entries):
|
|
print(f"{i + 1}. {m['entryname']}")
|
|
|
|
|
|
def create_config_file():
|
|
icons = user_args.icons
|
|
# Read current grub cfg
|
|
entries = get_entry_names()
|
|
|
|
entries_to_icons = {}
|
|
for icon, entry in zip(icons, entries):
|
|
entryname = entry.group("entryname")
|
|
if entryname in entries_to_icons:
|
|
warning(f"Duplicate entry '{entryname}'. Unexpected behaviour may occur. Consider changing names using Grub Customizer.")
|
|
entries_to_icons[entryname] = icon
|
|
|
|
config = {"icons": entries_to_icons}
|
|
|
|
with open(CONFIG_FILE_PATH, 'w') as f:
|
|
f.write(json.dumps(config))
|
|
|
|
|
|
def patch_from_config_file():
|
|
# Read current grub cfg
|
|
current_entries = get_entry_names()
|
|
|
|
with open(CONFIG_FILE_PATH) as f:
|
|
config = json.loads(f.read())
|
|
|
|
entries_to_icons = config["icons"]
|
|
|
|
icons = []
|
|
for entry in current_entries:
|
|
entryname = entry.group("entryname")
|
|
if entryname in entries_to_icons:
|
|
icons.append(entries_to_icons[entryname])
|
|
else:
|
|
warning(
|
|
f"{entryname} is a new grub menu entry, no icon will be set for it. "
|
|
f"Rerun matter.py to set icons"
|
|
)
|
|
icons.append("_")
|
|
|
|
do_patch_grub_cfg_icons(icons)
|
|
|
|
|
|
def do_patch_grub_cfg_icons(icons):
|
|
|
|
info(f"Begin {GRUB_CFG_PATH} patch")
|
|
with open(GRUB_CFG_PATH, "r", newline="") as f:
|
|
grub_cfg = f.read()
|
|
# Read current grub cfg
|
|
entries = get_entry_names()
|
|
|
|
# Build new grub cfg with given icons
|
|
new_grub_cfg = ""
|
|
next_seek = 0
|
|
for m, i in zip(entries, icons):
|
|
mstart, mend = m.span()
|
|
new_grub_cfg += grub_cfg[next_seek:mstart]
|
|
icon_class = f" --class {i} " if i != "_" else ""
|
|
new_grub_cfg += f'{m["head"]}"{m["entryname"]}"{icon_class}{m["tail"]}'
|
|
next_seek = mend
|
|
new_grub_cfg += grub_cfg[mend:]
|
|
|
|
# Write new grub cfg back
|
|
check_root_or_prompt()
|
|
with open(GRUB_CFG_PATH, "w") as f:
|
|
f.write(new_grub_cfg)
|
|
|
|
info(f"{len(icons)} icons successfully patched onto {GRUB_CFG_PATH}")
|
|
|
|
|
|
def do_set_icons(patch_grubcfg):
|
|
|
|
icons = user_args.icons
|
|
|
|
if icons is None:
|
|
error("Stop. Unspecified icons (--icons/-i argument)")
|
|
icons = [check_icon_converted(i) for i in icons]
|
|
|
|
# Read current grub cfg
|
|
entries = get_entry_names()
|
|
if len(icons) != len(entries):
|
|
error(
|
|
f"You must specify {len(entries)} "
|
|
f"icons ({len(icons)} provided) for entries:",
|
|
should_exit=False,
|
|
)
|
|
for i, m in enumerate(entries):
|
|
print(f"{i + 1}. {m['entryname']}")
|
|
# NOTE: We exit with 0 here to not stop the apt upgrade process
|
|
# eventually it will be solved with an autoremove
|
|
exit(0)
|
|
|
|
do_patch_grub_cfg_icons(user_args.icons)
|
|
|
|
if patch_grubcfg:
|
|
create_config_file()
|
|
|
|
# Patch grub-mkconfig so everytime it executes, it patches grub.cfg
|
|
info(f"Begin {GRUB_MKCONFIG_PATH} patch")
|
|
info(f"Clean old {GRUB_MKCONFIG_PATH} patch if any")
|
|
|
|
# cmd_icons = " ".join(user_args.icons)
|
|
# seticons_call = f"{INSTALLER_DIR}/{INSTALLER_NAME} -so -i {cmd_icons} >&2"
|
|
seticons_call = f"{INSTALLER_DIR}/{INSTALLER_NAME} --configicons >&2"
|
|
new_grub_mkconfig = read_cleaned_grub_mkconfig()
|
|
|
|
# grub-mkconfig is called on upgrade, and on failure it halts.
|
|
# A failure on our part should not halt an upgrade, let's temporarily
|
|
# disable the stop-on-error functionality with set +e. See #67
|
|
new_grub_mkconfig += (
|
|
f"\n\n{BEGIN_THEME_OVERRIDES}\n"
|
|
f"set +e\n"
|
|
f"{seticons_call}\n"
|
|
f"set -e\n"
|
|
f"{END_THEME_OVERRIDES}\n\n"
|
|
)
|
|
|
|
check_root_or_prompt()
|
|
with open(GRUB_MKCONFIG_PATH, "w") as f:
|
|
f.write(new_grub_mkconfig)
|
|
|
|
info(
|
|
f"{GRUB_MKCONFIG_PATH} successfully patched, icons will now persist between grub updates."
|
|
)
|
|
|
|
|
|
def install_hookcheck():
|
|
info(f"Create hook check script")
|
|
with open(HOOKCHECK_TEMPLATE_PATH, "r", newline="") as f:
|
|
template = f.read()
|
|
|
|
cmd_icons = " ".join(user_args.icons)
|
|
# seticons_call = f"{INSTALLER_DIR}/{INSTALLER_NAME} -so -i {cmd_icons} >&2"
|
|
seticons_call = f"{INSTALLER_DIR}/{INSTALLER_NAME} --configicons"
|
|
|
|
context = {
|
|
"GRUB_MKCONFIG_PATH": GRUB_MKCONFIG_PATH,
|
|
"THEME_NAME": THEME_NAME,
|
|
"THEME_OVERRIDES_TITLE": THEME_OVERRIDES_TITLE,
|
|
"BEGIN_THEME_OVERRIDES": BEGIN_THEME_OVERRIDES,
|
|
"END_THEME_OVERRIDES": END_THEME_OVERRIDES,
|
|
"SETICONS_CALL": seticons_call,
|
|
}
|
|
|
|
parsed_script = template.format(**context)
|
|
script_file_path = f"{GRUB_SCRIPTS_PATH}/99_matter"
|
|
|
|
with open(script_file_path, "w") as f:
|
|
f.write(parsed_script)
|
|
|
|
# Make it executable by user, group and others
|
|
st = os.stat(script_file_path)
|
|
os.chmod(script_file_path, st.st_mode | 0o111)
|
|
|
|
|
|
# Script arguments
|
|
|
|
|
|
def parse_args():
|
|
parser = ArgumentParser(
|
|
description=THEME_DESCRIPTION,
|
|
epilog=f"[Available colors] are: {', '.join(AVAILABLE_COLORS)}.\n"
|
|
"You can specify your own hex colors as well (e.g. C0FFEE, FF00FF, etc).\n"
|
|
f"[Available fonts] are: {', '.join(get_available_fonts())}\n"
|
|
"You can always specify your own with the -ff argument\n"
|
|
f"[Available icons] can be found at https://materialdesignicons.com/\n"
|
|
"For requests open an issue on:\n"
|
|
"https://github.com/mateosss/matter/issues",
|
|
formatter_class=RawTextHelpFormatter,
|
|
)
|
|
parser.add_argument(
|
|
"--listentries", "-l", action="store_true", help=f"list grub entries",
|
|
)
|
|
parser.add_argument(
|
|
"--buildonly",
|
|
"-b",
|
|
action="store_true",
|
|
help=f"prepare the theme but do not install it",
|
|
)
|
|
parser.add_argument(
|
|
"--test",
|
|
"-t",
|
|
action="store_true",
|
|
help=f"test the generated theme with grub2-theme-preview",
|
|
)
|
|
parser.add_argument(
|
|
"--icons",
|
|
"-i",
|
|
type=str,
|
|
nargs="*",
|
|
help=f"specify icons for each grub entry listed with -l",
|
|
)
|
|
parser.add_argument(
|
|
"--seticons",
|
|
"-si",
|
|
action="store_true",
|
|
help=f"set grub entries icons given by -i and patch grub-mkconfig for persistence",
|
|
)
|
|
parser.add_argument(
|
|
"--seticons_once",
|
|
"-so",
|
|
action="store_true",
|
|
help=f"set grub entries icons given by -i, will be reverted on next grub update",
|
|
)
|
|
parser.add_argument(
|
|
"--uninstall", "-u", action="store_true", help=f"uninstall {THEME_NAME}",
|
|
)
|
|
parser.add_argument(
|
|
"--highlight",
|
|
"-hl",
|
|
type=str,
|
|
help=f"selected text color",
|
|
default=THEME_DEFAULT_HIGHLIGHT,
|
|
)
|
|
parser.add_argument(
|
|
"--foreground",
|
|
"-fg",
|
|
type=str,
|
|
help=f"main text color",
|
|
default=THEME_DEFAULT_FOREGROUND,
|
|
)
|
|
parser.add_argument(
|
|
"--background",
|
|
"-bg",
|
|
type=str,
|
|
help=f"solid background color",
|
|
default=None,
|
|
# default will be set to THEME_DEFAULT_BACKGROUND
|
|
)
|
|
parser.add_argument(
|
|
"--image",
|
|
"-im",
|
|
type=str,
|
|
help=f"image file to use as background, supported extensions: PNG, JPG, JPEG, TGA",
|
|
)
|
|
parser.add_argument(
|
|
"--iconcolor",
|
|
"-ic",
|
|
type=str,
|
|
help=f"icons fill color, by default same as foreground",
|
|
)
|
|
parser.add_argument(
|
|
"--font",
|
|
"-f",
|
|
type=str,
|
|
help=f"theme font from already downloaded fonts",
|
|
default=THEME_DEFAULT_FONT,
|
|
choices=get_available_fonts(),
|
|
)
|
|
parser.add_argument(
|
|
"--fontfile", "-ff", type=str, help=f"import theme font from custom .ttf file"
|
|
)
|
|
parser.add_argument(
|
|
"--fontname",
|
|
"-fn",
|
|
type=str,
|
|
nargs="*",
|
|
help=f"specify the font name for the given font file",
|
|
)
|
|
parser.add_argument(
|
|
"--fontsize",
|
|
"-fs",
|
|
type=int,
|
|
help=f"theme font size",
|
|
default=THEME_DEFAULT_FONT_SIZE,
|
|
)
|
|
parser.add_argument(
|
|
"--configicons",
|
|
"-ci",
|
|
action="store_true",
|
|
help="set grub entries icons using config file. "
|
|
)
|
|
parser.add_argument(
|
|
"--downloadbackground",
|
|
"-dlbg",
|
|
type=str,
|
|
help=f"download the background image from the given url",
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
check_python_version()
|
|
user_args = parse_args()
|
|
|
|
if user_args.listentries:
|
|
do_list_grub_cfg_entries()
|
|
elif user_args.buildonly:
|
|
prepare_source_dir()
|
|
elif user_args.seticons_once:
|
|
do_set_icons(patch_grubcfg=False)
|
|
elif user_args.seticons:
|
|
do_set_icons(patch_grubcfg=True)
|
|
elif user_args.uninstall:
|
|
do_uninstall()
|
|
elif user_args.configicons:
|
|
patch_from_config_file()
|
|
elif user_args.icons is None:
|
|
do_preinstall_hint()
|
|
else:
|
|
do_install()
|
|
|
|
if user_args.test:
|
|
do_test()
|
|
except KeyboardInterrupt:
|
|
error("Stop. Script halted by user")
|
|
sys.exit(1)
|