sysmon_pytk.settings

  1# SPDX-FileCopyrightText: © 2024 Stacey Adams <stacey.belle.rose@gmail.com>
  2# SPDX-License-Identifier: MIT
  3
  4"""
  5Application settings.
  6"""
  7
  8from __future__ import annotations
  9
 10from configparser import ConfigParser
 11from pathlib import Path
 12from typing import TYPE_CHECKING
 13
 14from .font_utils import MAIN_FONT_FAMILY, FontDescription, FontSlant, FontWeight
 15
 16if TYPE_CHECKING:
 17    from tkinter.font import Font
 18
 19
 20class FontSettings:  # pylint: disable=too-many-instance-attributes
 21    """
 22    Manage the fonts used in the application.
 23
 24    Attributes
 25    ----------
 26    config : ConfigParser
 27        A configuration file parser.
 28    section : str
 29        Which section of the configuration file to use.
 30    """
 31
 32    def __init__(self, config: ConfigParser, section: str) -> None:
 33        """
 34        Construct a Font Settings manager.
 35
 36        Parameters
 37        ----------
 38        config : ConfigParser
 39            A configuration file parser.
 40        section : str
 41            Which section of the configuration file to use.
 42        """
 43        self.config = config
 44        self.section = section
 45
 46    @property
 47    def name(self) -> str:
 48        """
 49        The font name to use in the application.
 50        """
 51        return self.config[self.section].get("name", fallback=MAIN_FONT_FAMILY)
 52
 53    @name.setter
 54    def name(self, fontname: str) -> None:
 55        self.config[self.section]["name"] = fontname
 56
 57    @property
 58    def size(self) -> int:
 59        """
 60        The font size to use in the application.
 61        """
 62        return self.config[self.section].getint("size", fallback=12)
 63
 64    @size.setter
 65    def size(self, fontsize: int) -> None:
 66        self.config[self.section]["size"] = f"{fontsize}"
 67
 68    @property
 69    def weight(self) -> FontWeight:
 70        """
 71        The font weight to use in the application.
 72        """
 73        weight = self.config[self.section].get("weight", fallback="normal")
 74        if weight == "bold":
 75            return "bold"
 76        return "normal"
 77
 78    @weight.setter
 79    def weight(self, weight: str) -> None:
 80        self.config[self.section]["weight"] = weight
 81
 82    @property
 83    def slant(self) -> FontSlant:
 84        """
 85        The font slant to use in the application.
 86        """
 87        slant = self.config[self.section].get("slant", fallback="roman")
 88        if slant == "italic":
 89            return "italic"
 90        return "roman"
 91
 92    @slant.setter
 93    def slant(self, slant: str) -> None:
 94        self.config[self.section]["slant"] = slant
 95
 96    @property
 97    def underline(self) -> bool:
 98        """
 99        The font underline flag to use in the application.
100        """
101        return self.config[self.section].getboolean("underline", fallback=False)
102
103    @underline.setter
104    def underline(self, underline: bool) -> None:
105        self.config[self.section]["underline"] = f"{underline}"
106
107    @property
108    def overstrike(self) -> bool:
109        """
110        The font overstrike flag to use in the application.
111        """
112        return self.config[self.section].getboolean("overstrike", fallback=False)
113
114    @overstrike.setter
115    def overstrike(self, overstrike: bool) -> None:
116        self.config[self.section]["overstrike"] = f"{overstrike}"
117
118    def get_full_font(self) -> FontDescription:
119        """
120        Get the full font specification to use in the application.
121        """
122        return FontDescription(
123            family=self.name,
124            size=self.size,
125            weight=self.weight,
126            slant=self.slant,
127            underline=self.underline,
128            overstrike=self.overstrike
129        )
130
131    def set_full_font(self, font: FontDescription) -> None:
132        """
133        Set the full font specification to use in the application.
134        """
135        self.name = font.family
136        self.size = font.size
137        self.weight = font.weight
138        self.slant = font.slant
139        self.underline = font.underline
140        self.overstrike = font.overstrike
141
142    def configure_font(self, font: Font) -> None:
143        """
144        Configure an existing Font to use the current settings.
145        """
146        font.configure(
147            family=self.name,
148            size=self.size,
149            weight=self.weight,
150            slant=self.slant,
151            underline=self.underline,
152            overstrike=self.overstrike
153        )
154
155
156class Settings:
157    """
158    Manage the application settings.
159
160    Attributes
161    ----------
162    filename : str
163        The full path to the configuration file.
164    config : ConfigParser
165        A configuration file parser.
166    regular_font : FontSettings
167        Font settings for the regular font.
168    fixed_font : FontSettings
169        Font settings for the monospace font.
170    """
171
172    def __init__(self, filename: str) -> None:
173        """
174        Construct a Settings manager.
175
176        Parameters
177        ----------
178        filename : str
179            The full path to the configuration file.
180        """
181        self.filename = filename
182        self.config = ConfigParser()
183        self.read_settings()
184        self.regular_font = FontSettings(self.config, "font")
185        self.fixed_font = FontSettings(self.config, "fixedfont")
186
187    def read_settings(self) -> None:
188        """
189        Read the settings from the configuration file.
190        """
191        self.config.read(self.filename)
192        if not self.config.has_section("general"):
193            self.config.add_section("general")
194        if not self.config.has_section("font"):
195            self.config.add_section("font")
196        if not self.config.has_section("fixedfont"):
197            self.config.add_section("fixedfont")
198
199    def write_settings(self) -> None:
200        """
201        Write the settings to the configuration file.
202        """
203        with Path(self.filename).open(mode="w", encoding="utf-8") as file:
204            self.config.write(file)
205
206    @property
207    def theme(self) -> str:
208        """
209        The application theme.
210        """
211        return self.config["general"].get("theme", fallback="Light")
212
213    @theme.setter
214    def theme(self, theme: str) -> None:
215        self.config["general"]["theme"] = theme
216
217    @property
218    def always_on_top(self) -> int:
219        """
220        The flag indicating whether the application should always be on top.
221        """
222        return self.config["general"].getint("always_on_top", fallback=0)
223
224    @always_on_top.setter
225    def always_on_top(self, always_on_top: int) -> None:
226        self.config["general"]["always_on_top"] = f"{always_on_top}"
227
228    @property
229    def add_menu_icon(self) -> int:
230        """
231        The flag indicating whether the application should add a menu icon.
232        """
233        return self.config["general"].getint("add_menu_icon", fallback=0)
234
235    @add_menu_icon.setter
236    def add_menu_icon(self, add_menu_icon: int) -> None:
237        self.config["general"]["add_menu_icon"] = f"{add_menu_icon}"
238
239    @property
240    def language(self) -> str:
241        """
242        The language to use.
243        """
244        return self.config["general"].get("language", fallback="en")
245
246    @language.setter
247    def language(self, language: str) -> None:
248        self.config["general"]["language"] = language