sysmon_pytk.modals

 30class ModalDialog(ButtonMixin, tk.Toplevel, metaclass=ABCMeta):
 31    """
 32    Base class for modal dialogs.
 33
 34    Attributes
 35    ----------
 36    parent : Misc, optional
 37        The parent widget.
 38    iconpath : str, optional
 39        The path to the icon to display in the window title bar.
 40    internal_frame : Frame
 41        A `Frame` to manage the widgets added to the dialog.
 42    base_font : Font
 43        Standard font to use for widgets.
 44    large_font : Font
 45        Large font to use for headers.
 46    bold_font : Font
 47        Bold font to use for widgets.
 48    fixed_font : Font
 49        Fixed font to use for widgets.
 50    _events : list[str]
 51        A list of event sequences to trigger after save and dismiss.
 52    """
 53
 54    def __init__(
 55        self, parent: Misc | None = None, *, title: str | None = None,
 56        iconpath: str | None = None, class_: str = "ModalDialog"
 57    ) -> None:
 58        """
 59        Construct a modal dialog.
 60
 61        Parameters
 62        ----------
 63        parent : Misc, optional
 64            The parent widget.
 65        title : str, optional
 66            The title to display in the window title bar.
 67        iconpath : str, optional
 68            The path to the icon to display in the window title bar.
 69        class_ : str, default = "ModalDialog"
 70            The class name of this modal dialog, used with the option database
 71            for styling.
 72        """
 73        super().__init__(parent, class_=class_)
 74        self.parent = parent
 75        self.iconpath = iconpath
 76        self._events: list[str] = []
 77        self.title(title)
 78        if self.iconpath is not None:
 79            self.iconphoto(False, tk.PhotoImage(file=self.iconpath))
 80        self.internal_frame = ttk.Frame(self)
 81        self.internal_frame.grid(sticky=tk.NSEW)
 82        self.load_fonts()
 83        self.bind_events()
 84        self.create_widgets()
 85        self.update_screen()
 86        top = self.winfo_toplevel()
 87        top.rowconfigure(0, weight=1)
 88        top.columnconfigure(0, weight=1)
 89        self.make_modal()
 90        self.wait_window()
 91
 92    @final
 93    def load_fonts(self) -> None:
 94        """
 95        Load the standard fonts from the `sysmon_pytk.style_manager.StyleManager`.
 96        """
 97        self.base_font = StyleManager.get_base_font()
 98        self.large_font = StyleManager.get_large_font()
 99        self.bold_font = StyleManager.get_bold_font()
100        self.fixed_font = StyleManager.get_fixed_font()
101
102    @final
103    def bind_events(self) -> None:
104        """
105        Bind window events.
106        """
107        self.protocol("WM_DELETE_WINDOW", self.dismiss)
108        self.bind("<KeyPress-Escape>", self.dismiss)
109        self.bind("<KeyPress-Return>", self.save_and_dismiss)
110        self.bind("<KeyPress-KP_Enter>", self.save_and_dismiss)
111
112    @final
113    def make_modal(self) -> None:
114        """
115        Make this behave like a modal window.
116        """
117        self.transient(self.parent)  # type: ignore[arg-type]
118        self.wait_visibility()
119        self.grab_set()
120        self.minsize(self.winfo_width(), self.winfo_height())
121
122    @final
123    def dismiss(self, *_args) -> None:
124        """
125        Dismiss the modal dialog.
126
127        This should be bound to Cancel and Close buttons in subclasses.
128        """
129        self.grab_release()
130        self.destroy()
131
132    @final
133    def save_and_dismiss(self, *_args) -> None:
134        """
135        Save what was entered in the modal dialog and dismiss it.
136
137        This should be bound to OK and Save buttons in subclasses.
138        """
139        self.on_save()
140        self.dismiss()
141        if self.parent:
142            for event in self._events:
143                self.parent.event_generate(event)
144
145    @final
146    def save_dismiss_event(self, event_str: str) -> None:
147        """
148        Accumulate a list of events to trigger on dismissal when saving.
149        """
150        if event_str not in self._events:
151            self._events.append(event_str)
152
153    @final
154    def add_close_button(self) -> None:
155        """
156        Add a Close button to the bottom row of the modal dialog.
157        """
158        buttons = [
159            ButtonDefinition(text=_("Close"), command=self.dismiss),
160        ]
161        self.add_buttons(self.internal_frame, buttons=buttons, default=0)
162
163    @final
164    def add_ok_cancel_buttons(self) -> None:
165        """
166        Add OK and Cancel buttons to the bottom row of the modal dialog.
167        """
168        buttons = [
169            ButtonDefinition(text=_("Cancel"), command=self.dismiss),
170            ButtonDefinition(text=_("OK"), command=self.save_and_dismiss),
171        ]
172        self.add_buttons(self.internal_frame, buttons=buttons, default=1)
173
174    @final
175    def add_sizegrip(self) -> None:
176        """
177        Add a ttk.Sizegrip widget to the bottom row of the modal dialog.
178        """
179        max_columns, max_rows = self.internal_frame.grid_size()
180        ttk.Sizegrip(self.internal_frame).grid(
181            row=max_rows, column=max_columns-1, sticky=tk.SE, padx=INTERNAL_PAD/2,
182            pady=INTERNAL_PAD/2
183        )
184
185    @abstractmethod
186    def on_save(self) -> None:
187        """
188        Save what was entered in the modal dialog.
189        """
190
191    @abstractmethod
192    def create_widgets(self) -> None:
193        """
194        Create the widgets to be displayed in the modal dialog.
195        """
196
197    @abstractmethod
198    def update_screen(self) -> None:
199        """
200        Update the modal dialog window.
201        """

 88class AboutDialog(ModalDialog):
 89    """
 90    Display metadata about the application in a modal dialog.
 91
 92    Attributes
 93    ----------
 94    about : AboutMetadata
 95        Metadata about the application to be displayed.
 96    logo : PhotoImage
 97        A logo to be displayed.
 98    """
 99
100    def __init__(
101        self, parent: Misc | None, about: AboutMetadata, iconpath: str | None = None
102    ) -> None:
103        """
104        Construct a modal dialog containing metadata about the application.
105
106        Parameters
107        ----------
108        parent : Misc, optional
109            The parent widget.
110        about : AboutMetadata
111            The metadata about the application.
112        iconpath : str, optional
113            The path to the icon to display in the window title bar.
114        """
115        self.about = about
116        title = _("About {}").format(about.app_name).strip()
117        self.logo = tk.PhotoImage(file=get_full_path("images/icon-lg.png"))
118        super().__init__(parent, title=title, iconpath=iconpath, class_="AboutBox")
119
120    def update_screen(self) -> None:
121        """
122        Update the modal dialog window.
123
124        This dialog does not require screen updates.
125        """
126
127    def on_save(self) -> None:
128        """
129        Save what was entered in the modal dialog.
130
131        This dialog does not need a save feature.
132        """
133
134    def create_widgets(self) -> None:
135        """
136        Create the widgets to be displayed in the modal dialog.
137        """
138        self.internal_frame.rowconfigure(0, weight=1)
139        self.internal_frame.columnconfigure(0, weight=1)
140        notebook = ttk.Notebook(self.internal_frame)
141        notebook.grid(
142            row=0, sticky=tk.NSEW, padx=INTERNAL_PAD/2, pady=INTERNAL_PAD/2
143        )
144        notebook.add(
145            self.create_about_tab(notebook), text=self.title(), sticky=tk.NSEW
146        )
147        notebook.add(
148            self.create_translators_tab(notebook), text=_("Translators"),
149            sticky=tk.NSEW
150        )
151        if self.about.license is not None:
152            notebook.add(
153                self.create_license_tab(notebook, self.about.license),
154                text=_("License"), sticky=tk.NSEW
155            )
156        notebook.enable_traversal()
157        self.add_close_button()
158        self.add_sizegrip()
159
160    def create_about_tab(self, notebook: ttk.Notebook) -> ttk.Frame:
161        """
162        Create the About page of the Notebook widget.
163        """
164        text = ScrollingText(
165            notebook, font=self.base_font, height=11, width=50, wrap=tk.WORD,
166            undo=False, relief=tk.FLAT, spacing1=INTERNAL_PAD
167        )
168        tab = text.get_frame()
169        text.image_create(tk.END, image=self.logo)
170        text.insert(tk.END, "\n")
171        text.insert(tk.END, self.about.get_name() + "\n", "large")
172        text.insert(tk.END, _("Version {}").format(self.about.get_version_string()) + "\n")
173        copyright_text = self.about.get_copyright_text()
174        if copyright_text:
175            text.insert(tk.END, copyright_text + "\n")
176        if self.about.url:
177            token = uuid4().hex
178            text.insert(tk.END, _("Source Code"), ("link", token))
179            text.insert(tk.END, self.about.url, "linkurl")
180            text.insert(tk.END, "\n")
181            TextToolTip(text, self.about.url, token)
182        text.tag_add("center", "1.0", "end-1c")
183        text.insert(tk.END, self.about.description)
184        text.config(state=tk.DISABLED, padx=INTERNAL_PAD)
185        return tab
186
187    def create_translators_tab(self, notebook: ttk.Notebook) -> ttk.Frame:
188        """
189        Create the Translators page of the Notebook widget.
190        """
191        text = ScrollingText(
192            notebook, font=self.base_font, height=10, width=50, wrap=tk.WORD,
193            undo=False, relief=tk.FLAT
194        )
195        tab = text.get_frame()
196        for language, translator_list in TRANSLATORS.items():
197            text.insert(tk.END, f"{language}: ", "bold")
198            for idx, translator in enumerate(translator_list):
199                self._add_translator(text, translator, idx, len(translator_list))
200        text.delete("end-1c")  # remove the final "\n"
201        text.config(state=tk.DISABLED, spacing1=4, spacing2=4, spacing3=4)
202        return tab
203
204    def _add_translator(
205        self, text: tk.Text, translator: Translator, idx: int, max_items: int
206    ) -> None:
207        text.insert(tk.END, translator.name)
208        if translator.github_username:
209            token = uuid4().hex
210            text.insert(tk.END, " (")
211            text.insert(tk.END, f"{translator.github_username} @ GitHub", ("link", token))
212            text.insert(tk.END, translator.github_url(), "linkurl")
213            text.insert(tk.END, ")")
214            TextToolTip(text, translator.github_url(), token)
215        if idx < max_items-1:
216            text.insert(tk.END, ", ")
217        else:
218            text.insert(tk.END, "\n")
219
220    def create_license_tab(
221        self, notebook: ttk.Notebook, license_data: LicenseMetadata
222    ) -> ttk.Frame:
223        """
224        Create the License details page of the Notebook widget.
225        """
226        text = ScrollingText(
227            notebook, font=self.base_font, height=15, width=50, wrap=tk.WORD,
228            undo=False, relief=tk.FLAT
229        )
230        tab = text.get_frame()
231        if license_data.full_license:
232            license_text = [
233                paragraph.replace(
234                    "\n", " "
235                ) for paragraph in license_data.full_license.split("\n\n")
236            ]
237            text.insert(tk.END, "\n\n".join(license_text))
238        elif license_data.license_name:
239            text.config(spacing1=4, spacing2=4, spacing3=4, height=5)
240            text.insert(tk.END, license_data.license_name + "\n")
241            if license_data.license_url:
242                token = uuid4().hex
243                text.insert(tk.END, _("Full license text available here"), ("link", token))
244                text.insert(tk.END, license_data.license_url, "linkurl")
245                TextToolTip(text, license_data.license_url, token)
246            text.tag_add("center", "1.0", "end-1c")
247        text.config(state=tk.DISABLED)
248        return tab

44@dataclasses.dataclass
45class AboutMetadata:
46    """
47    Metadata about the application.
48    """
49
50    app_name: str
51    """The application name."""
52    version: str
53    """The current version of the application."""
54    author: str
55    """The author of the application."""
56    copyright_year: str
57    """The copyright year of the application."""
58    description: str
59    """A description of the application."""
60    url: str
61    """A URL that points to the source code repository for the application."""
62    license: LicenseMetadata | None = None
63    """License metadata about the application."""
64
65    def get_copyright_text(self) -> str:
66        """
67        Build the copyright text based on year and author.
68        """
69        if self.author:
70            if self.copyright_year:
71                return f"© {self.copyright_year} {self.author}"
72            return f"© {self.author}"
73        return ""
74
75    def get_name(self) -> str:
76        """
77        Return the app name meta data if available; otherwise, main script name.
78        """
79        return self.app_name if self.app_name else get_main_script()
80
81    def get_version_string(self) -> str:
82        """
83        Return a string containing the version if available; otherwise, 0.0.1.
84        """
85        return self.version if self.version else "0.0.1"

30@dataclasses.dataclass
31class LicenseMetadata:
32    """
33    Metadata about the license used by the application.
34    """
35
36    full_license: str
37    """The full license text for the application. Can be an empty string."""
38    license_name: str
39    """The name of the license used by the application."""
40    license_url: str
41    """A URL pointing to an online copy of the license text."""

 28class CpuDialog(ModalDialog):
 29    """
 30    Display individual CPU core usage details in a modal dialog.
 31
 32    Attributes
 33    ----------
 34    cpu_count : int
 35        The number of logical CPUs in the system.
 36    """
 37
 38    MAX_COLUMNS = 4
 39
 40    def __init__(
 41        self, parent: Misc | None = None, *, title: str | None = None,
 42        iconpath: str | None = None
 43    ) -> None:
 44        """
 45        Construct a modal dialog containing information about CPU usage.
 46
 47        Parameters
 48        ----------
 49        parent : Misc, optional
 50            The parent widget.
 51        title : str, optional
 52            The title to display in the window title bar.
 53        iconpath : str, optional
 54            The path to the icon to display in the window title bar.
 55        """
 56        self._max_used_column = 0
 57        super().__init__(parent, title=title, iconpath=iconpath)
 58
 59    def on_save(self) -> None:
 60        """
 61        Save what was entered in the modal dialog.
 62
 63        This dialog does not need a save feature.
 64        """
 65
 66    def create_widgets(self) -> None:
 67        """
 68        Create the widgets to be displayed in the modal dialog.
 69        """
 70        self.cpu_count = psutil.cpu_count()
 71        self.internal_frame.columnconfigure(0, weight=1)
 72        self.internal_frame.columnconfigure(1, weight=1)
 73        self.internal_frame.columnconfigure(2, weight=1)
 74        self.internal_frame.columnconfigure(3, weight=1)
 75        self._meter_rows: list[int] = []
 76        self._meters: list[Meter] = []
 77        self._freqmeters: list[Meter] = []
 78        ttk.Label(
 79            self.internal_frame, text=_common.get_processor_name(),
 80            font=self.large_font, anchor=tk.CENTER
 81        ).grid(columnspan=self.MAX_COLUMNS, sticky=tk.EW, ipady=_common.INTERNAL_PAD)
 82        ttk.Label(
 83            self.internal_frame, text=_("per-core CPU Usage"),
 84            font=self.large_font, anchor=tk.CENTER
 85        ).grid(columnspan=self.MAX_COLUMNS, row=1, sticky=tk.EW)
 86        row = 2
 87        row = self._create_usage_widgets(row) + 1
 88        ttk.Label(
 89            self.internal_frame, text=_("per-core CPU Frequency (in MHz)"),
 90            font=self.large_font, anchor=tk.CENTER
 91        ).grid(columnspan=self.MAX_COLUMNS, row=row, sticky=tk.EW)
 92        row = self._create_freq_widgets(row+1) + 1
 93        for meter_row in self._meter_rows:
 94            self.internal_frame.rowconfigure(meter_row, weight=1)
 95        self.add_close_button()
 96        self.add_sizegrip()
 97
 98    def _create_usage_widgets(self, start_row: int) -> int:
 99        row = start_row
100        col = 0
101        for core in range(self.cpu_count):
102            meter = Meter(
103                self.internal_frame, width=220, height=165, unit="%",
104                label=_("CPU #{}").format(core)
105            )
106            meter.grid(row=row, column=col, sticky=tk.NSEW, ipady=_common.INTERNAL_PAD)
107            if row not in self._meter_rows:
108                self._meter_rows.append(row)
109            self._meters.append(meter)
110            self._max_used_column = max(self._max_used_column, col)
111            col += 1
112            if col == self.MAX_COLUMNS:
113                col = 0
114                row += 1
115        return row
116
117    def _create_freq_widgets(self, start_row: int) -> int:
118        row = start_row
119        col = 0
120        freqs = psutil.cpu_freq(percpu=True)
121        for core in range(self.cpu_count):
122            meter = Meter(
123                self.internal_frame, width=220, height=165, unit="",
124                label=_("CPU #{}").format(core),
125                min_value=freqs[core].min, max_value=freqs[core].max  # type: ignore[attr-defined]
126            )
127            meter.grid(row=row, column=col, sticky=tk.NSEW, ipady=_common.INTERNAL_PAD)
128            if row not in self._meter_rows:
129                self._meter_rows.append(row)
130            self._freqmeters.append(meter)
131            self._max_used_column = max(self._max_used_column, col)
132            col += 1
133            if col == self.MAX_COLUMNS:
134                col = 0
135                row += 1
136        return row
137
138    def update_screen(self) -> None:
139        """
140        Update the modal dialog window.
141        """
142        usage = psutil.cpu_percent(interval=None, percpu=True)
143        for core in range(self.cpu_count):
144            self._meters[core].set_value(usage[core])
145        freqs = psutil.cpu_freq(percpu=True)
146        for core in range(self.cpu_count):
147            self._freqmeters[core].set_value(freqs[core].current)  # type: ignore[attr-defined]
148        self.after(_common.REFRESH_INTERVAL, self.update_screen)