sysmon_pytk.widgets

23class AutoScrollbar(ttk.Scrollbar):  # pylint: disable=too-many-ancestors
24    """
25    A scrollbar that automatically removes itself when not needed.
26    """
27
28    def set(self, first: Any, last: Any) -> None:  # noqa: ANN401
29        """
30        Set the fractional values of the slider position.
31
32        Parameters
33        ----------
34        first : Any
35            A string representation of a float, between 0 and 1.
36        last : Any
37            A string representation of a float, between 0 and 1.
38        """
39        if float(first) <= 0 and float(last) >= 1:
40            self.grid_remove()
41        else:
42            self.grid()
43        super().set(first, last)
44
45    def pack(self, **_kwargs):  # noqa: ANN201
46        """
47        Disable pack for this widget.
48        """
49        msg = "cannot use pack with this widget"
50        raise TclError(msg)
51
52    def place(self, **_kwargs):  # noqa: ANN201
53        """
54        Disable place for this widget.
55        """
56        msg = "cannot use place with this widget"
57        raise TclError(msg)
58
59    @classmethod
60    def add_to_widget(
61        cls, widget: ScrollableWidget, orient: Literal["horizontal", "vertical"],
62        **kwargs
63    ) -> Self:
64        """
65        Add a scrollbar to a scrollable widget.
66
67        Parameters
68        ----------
69        widget : ScrollableWidget
70            The parent widget that will be linked to this scrollbar.
71        orient : Literal["horizontal", "vertical"]
72            The scrollbar orientation: horizontal or vertical.
73        **kwargs : dict, optional
74            Arguments to pass to parent `Scrollbar` class.
75        """
76        scroller = cls(widget.master, orient=orient, **kwargs)
77        if orient == "horizontal":
78            scroller.config(command=widget.xview)
79            widget.config(xscrollcommand=scroller.set)
80        else:
81            scroller.config(command=widget.yview)
82            widget.config(yscrollcommand=scroller.set)
83        return scroller

21class DropDown(ttk.Combobox):
22    """
23    A Combobox that takes a dict for values.
24
25    Dict keys are used for display, and dict values are used for the
26    value set or returned.
27
28    Attributes
29    ----------
30    dictionary : dict
31        The dictionary to use in the dropdown.
32    """
33
34    def __init__(self, parent: BaseWidget, dictionary: dict, **kwargs) -> None:
35        """
36        Construct a dropdown widget.
37
38        Parameters
39        ----------
40        parent : BaseWidget
41            The parent widget.
42        dictionary : dict
43            The dictionary to use in the dropdown.
44        **kwargs : dict, optional
45            Additional keyword arguments for a `Combobox`.
46        """
47        super().__init__(
48            parent, values=sorted(dictionary.keys()), **kwargs
49        )
50        self.dictionary = dictionary
51
52    def get(self) -> str:
53        """
54        Get the selected value of the dropdown.
55        """
56        key = super().get()
57        return self.dictionary[key] if key else ""
58
59    def set(self, value: str) -> None:
60        """
61        Set the value of the dropdown, if value is found in the dictionary.
62        """
63        keys = [key for key, val in self.dictionary.items() if val == value]
64        if len(keys) > 0:
65            super().set(keys[0])

20@dataclasses.dataclass
21class EditMenuImages:
22    """
23    Images used for the Edit Menu.
24    """
25
26    cut: tk.PhotoImage
27    """Image for Cut."""
28    copy: tk.PhotoImage
29    """Image for Copy."""
30    paste: tk.PhotoImage
31    """Image for Paste."""
32    select_all: tk.PhotoImage
33    """Image for Select All."""

 36class EditMenu(tk.Menu):
 37    """
 38    Standard Edit Menu with Cut/Copy/Paste/Select All items.
 39
 40    Attributes
 41    ----------
 42    images : `EditMenuImages`
 43        A collection of images needed for the menu.
 44    """
 45
 46    def __init__(self, master: tk.Text, **kwarg) -> None:
 47        """
 48        Construct an edit menu for a Text widget.
 49
 50        Parameters
 51        ----------
 52        master : tk.Text
 53            The parent Text widget.
 54        **kwarg : dict, optional
 55            Additional keyword arguments for a `Menu`.
 56        """
 57        self.master: tk.Text = master
 58        super().__init__(master, **kwarg)
 59        self.images = EditMenuImages(
 60            cut=tk.PhotoImage(file=get_full_path("images/edit-cut.png")),
 61            copy=tk.PhotoImage(file=get_full_path("images/edit-copy.png")),
 62            paste=tk.PhotoImage(file=get_full_path("images/edit-paste.png")),
 63            select_all=tk.PhotoImage(file=get_full_path("images/edit-select-all.png"))
 64        )
 65        self.add_command(
 66            label=_("Cut"), command=self.cut, accelerator=_("Ctrl+X"),
 67            compound=tk.LEFT, image=self.images.cut
 68        )
 69        self.add_command(
 70            label=_("Copy"), command=self.copy, accelerator=_("Ctrl+C"),
 71            compound=tk.LEFT, image=self.images.copy
 72        )
 73        self.add_command(
 74            label=_("Paste"), command=self.paste, accelerator=_("Ctrl+V"),
 75            compound=tk.LEFT, image=self.images.paste
 76        )
 77        self.add_separator()
 78        self.add_command(
 79            label=_("Select All"), command=self.select_all,
 80            accelerator=_("Ctrl+A"), compound=tk.LEFT, image=self.images.select_all
 81        )
 82        self.master.bind("<Button-3>", self.show_popup)
 83        self.master.bind("<Control-X>", self.cut)
 84        self.master.bind("<Control-C>", self.copy)
 85        self.master.bind("<Control-V>", self.paste)
 86        self.master.bind("<Control-A>", self.select_all)
 87
 88    def show_popup(self, event: tk.Event) -> None:
 89        """
 90        Show the edit menu.
 91        """
 92        if self.focus_get() != self:
 93            self.focus_set()
 94        if self.master.cget("state") == tk.DISABLED:
 95            self.entryconfigure(_("Cut"), state=tk.DISABLED)
 96            self.entryconfigure(_("Paste"), state=tk.DISABLED)
 97        else:
 98            self.entryconfigure(_("Cut"), state=tk.NORMAL)
 99            self.entryconfigure(_("Paste"), state=tk.NORMAL)
100        self.tk_popup(event.x_root, event.y_root, 0)
101
102    def cut(self, *_args) -> None:
103        """
104        Generate a Cut Text event.
105        """
106        if self.master.cget("state") == tk.NORMAL:
107            self.master.event_generate("<<Cut>>")
108
109    def copy(self, *_args) -> None:
110        """
111        Generate a Copy Text event.
112        """
113        self.master.event_generate("<<Copy>>")
114
115    def paste(self, *_args) -> None:
116        """
117        Generate a Paste Text event.
118        """
119        if self.master.cget("state") == tk.NORMAL:
120            self.master.event_generate("<<Paste>>")
121
122    def select_all(self, *_args) -> None:
123        """
124        Select all the text in the Text widget.
125        """
126        self.master.tag_add(tk.SEL, "1.0", "end-1c")

 42class Meter(tk.Frame):
 43    """
 44    Shows a meter widget, like a speedometer.
 45    """
 46
 47    GREEN = "#0a0"
 48    YELLOW = "#dd0"
 49    RED = "#d00"
 50    BLUE = "#00a"
 51
 52    START_ANGLE = 36
 53    EXTENT_ANGLE = 180 - 2*START_ANGLE
 54
 55    def __init__(
 56            self, parent: Misc, *,
 57            width: int = 300, height: int = 225,
 58            min_value: float = 0.0, max_value: float = 100.0,
 59            label: str = "", unit: str = "",
 60            divisions: int = 10, yellow: float = 15,
 61            red: float = 15, blue: float = 0, **kw
 62    ) -> None:
 63        """
 64        Construct a meter widget.
 65
 66        Parameters
 67        ----------
 68        parent : Misc
 69            The parent widget.
 70        width : int, default = 300
 71            The width of the meter widget.
 72        height : int, default = 225
 73            The height of the meter widget.
 74        min_value : float, default = 0.0
 75            The minimum value to display on the meter.
 76        max_value : float, default = 100.0
 77            The maximum value to display on the meter.
 78        label : str, default = ""
 79            The label to display above the meter.
 80        unit : str, default = ""
 81            The units, used when displaying numbers on the meter.
 82        divisions : int, default = 10
 83            The number of divisions between the start and end of the meter.
 84        yellow : float, default = 15
 85            The percent of the meter to show in yellow. Appears just before red.
 86        red : float, default = 15
 87            The percent of the meter to show in red. Appears at the max values.
 88        blue : float, default = 0
 89            The percent of the meter to show in blue. Appears at the min values.
 90        **kw : dict, optional
 91            Arguments to pass to parent `Frame` class.
 92        """
 93        self._unit = unit
 94        self._min_value = min_value
 95        self._max_value = max_value
 96        self._width = width
 97        self._height = height
 98        self._divisions = divisions
 99        self.range = {"blue": blue, "yellow": yellow, "red": red}
100        self.check_dark_mode()
101        super().__init__(parent, background=self._background, class_="Meter", **kw)
102        self.var = tk.DoubleVar(self, 0)
103        self.rowconfigure(0, weight=1)
104        self.columnconfigure(0, weight=1)
105        # This `canvas_holder` frame is to keep the canvas centered in the widget.
106        canvas_holder = tk.Frame(self)
107        canvas_holder.grid()
108        self.canvas = tk.Canvas(
109            canvas_holder,
110            width=width,
111            height=height,
112            background=self._background,
113            borderwidth=0,
114            highlightthickness=0
115        )
116        self.canvas_objects = CanvasObjects()
117        self._add_labels(label, unit)
118        self._add_gauge_lines(red, yellow, blue)
119        self._add_inset()
120        self._update_meter_line(Meter.EXTENT_ANGLE + Meter.START_ANGLE)
121        self.var.trace_add("write", self._update_meter)
122        self.canvas.grid(sticky=tk.EW)
123
124    def _add_labels(self, label: str, unit: str) -> None:
125        font_size_lg = int(self._height / 15)
126        font_size_sm = int(self._height / 20)
127        text_font = modify_named_font("TkDefaultFont", size=font_size_lg)
128        large_font = modify_named_font("TkFixedFont", size=font_size_lg)
129        small_font = modify_named_font("TkFixedFont", size=font_size_sm)
130        # Add text: label, mix, max, current
131        self.canvas_objects.label1 = self.canvas.create_text(
132            self._width / 2, self._height / 10,
133            font=text_font, text=label, fill=self._text_color
134        )
135        self.canvas_objects.min_value = self.canvas.create_text(
136            self._width / 6, self._height * 0.55,
137            font=small_font, text=f"{int(self._min_value)}{unit}",
138            fill=self._text_color, anchor=tk.NE, justify=tk.RIGHT
139        )
140        self.canvas_objects.max_value = self.canvas.create_text(
141            self._width * 5 / 6, self._height * 0.55,
142            font=small_font, text=f"{int(self._max_value)}{unit}",
143            fill=self._text_color, anchor=tk.NW, justify=tk.LEFT
144        )
145        self.canvas_objects.current = self.canvas.create_text(
146            self._width / 2, self._height - 1.75*font_size_lg,
147            font=large_font, text=f"{self.var.get()}{self._unit}",
148            fill=self._text_color, anchor=tk.N, justify=tk.CENTER
149        )
150
151    def _add_gauge_lines(self, red: float, yellow: float, blue: float) -> None:
152        coord = (
153            self._width / 30, self._height / 4,
154            self._width * 29 / 30, self._height * 1.5
155        )
156        # Add the divisions
157        self.canvas_objects.wedges = []
158        for i in range(self._divisions):
159            self.canvas_objects.wedges.append(self.canvas.create_arc(
160                coord, width=1, outline=self._text_color,
161                start=(i * (Meter.EXTENT_ANGLE / self._divisions) + Meter.START_ANGLE),
162                extent=(Meter.EXTENT_ANGLE / self._divisions)
163            ))
164
165        # Add the color scale arcs
166        self.canvas.create_arc(
167            coord, extent=Meter.EXTENT_ANGLE, start=Meter.START_ANGLE,
168            style="arc", outline=self.GREEN, width=self._width / 12
169        )
170        if red > 0:
171            self.canvas.create_arc(
172                coord, extent=self._percent_to_degrees(red), start=Meter.START_ANGLE,
173                style="arc", outline=self.RED, width=self._width / 12
174            )
175        if yellow > 0:
176            self.canvas.create_arc(
177                coord, extent=self._percent_to_degrees(yellow),
178                start=self._percent_to_degrees(red) + Meter.START_ANGLE,
179                style="arc", outline=self.YELLOW, width=self._width / 12
180            )
181        if blue > 0:
182            self.canvas.create_arc(
183                coord, start=Meter.EXTENT_ANGLE + Meter.START_ANGLE,
184                extent=-self._percent_to_degrees(blue),
185                style="arc", outline=self.BLUE, width=self._width / 12
186            )
187
188        # Add the moving indicator line
189        self.canvas_objects.meter = self.canvas.create_arc(
190            coord, start=Meter.EXTENT_ANGLE + Meter.START_ANGLE, extent=1,
191            fill=self._meter_color, outline=self._meter_color, width=3
192        )
193
194    def _add_inset(self) -> None:
195        # Add the inset
196        inset_coord = (
197            self._width * 23 / 60, self._height * 23 / 32,
198            self._width * 37 / 60, self._height * 33 / 32
199        )
200        self.canvas_objects.inset = self.canvas.create_arc(
201            inset_coord, start=Meter.START_ANGLE, extent=Meter.EXTENT_ANGLE,
202            fill=self._text_color, outline=self._text_color, width=2
203        )
204        self.canvas_objects.inset_border = self.canvas.create_arc(
205            inset_coord, start=Meter.START_ANGLE, extent=Meter.EXTENT_ANGLE,
206            outline=self._meter_color, style="arc", width=1
207        )
208
209    def check_dark_mode(self) -> None:
210        """
211        Detect whether using dark mode and adjust base colors.
212        """
213        style = ttk.Style()
214        self._text_color = style.lookup("TLabel", "foreground")
215        self._background = style.lookup("TLabel", "background")
216        self._meter_color = StyleManager.test_dark_mode("#cccccc", "#666666")
217        self._meter_red = StyleManager.test_dark_mode("#ff2222", "#cc0000")
218        self._meter_yellow = StyleManager.test_dark_mode("#ffff22", "#cccc00")
219        self._meter_blue = StyleManager.test_dark_mode("#2222ff", "#0000cc")
220
221    def update_for_dark_mode(self) -> None:
222        """
223        Update the meter colors based on detected dark mode.
224        """
225        self.check_dark_mode()
226        self.canvas.config(background=self._background)
227        self.canvas.itemconfig(self.canvas_objects.label1, fill=self._text_color)
228        self.canvas.itemconfig(self.canvas_objects.min_value, fill=self._text_color)
229        self.canvas.itemconfig(self.canvas_objects.max_value, fill=self._text_color)
230        self.canvas.itemconfig(self.canvas_objects.current, fill=self._text_color)
231        self.canvas.itemconfig(self.canvas_objects.meter, fill=self._meter_color)
232        self.canvas.itemconfig(self.canvas_objects.meter, outline=self._meter_color)
233        self.canvas.itemconfig(self.canvas_objects.inset, fill=self._text_color)
234        self.canvas.itemconfig(self.canvas_objects.inset, outline=self._text_color)
235        self.canvas.itemconfig(self.canvas_objects.inset_border, outline=self._text_color)
236        for wedge in self.canvas_objects.wedges:
237            self.canvas.itemconfig(wedge, outline=self._text_color)
238
239    def _update_meter_line(self, angle: float) -> None:
240        """
241        Update the meter line indicator.
242        """
243        self.canvas.itemconfig(self.canvas_objects.meter, start=angle)
244        self.canvas.itemconfig(self.canvas_objects.current, text=f"{self.var.get()}{self._unit}")
245
246    def _update_meter(self, _name1, _name2, _op) -> None:
247        """
248        Update the meter display based on the updated variable.
249        """
250        pct = (self.var.get() - self._min_value)/(self._max_value - self._min_value)
251        if pct * 100 < self.range["blue"]:
252            self.canvas.itemconfig(self.canvas_objects.meter, fill=self._meter_blue)
253            self.canvas.itemconfig(self.canvas_objects.meter, outline=self._meter_blue)
254        elif pct * 100 > 100 - self.range["red"]:
255            self.canvas.itemconfig(self.canvas_objects.meter, fill=self._meter_red)
256            self.canvas.itemconfig(self.canvas_objects.meter, outline=self._meter_red)
257        elif pct * 100 > 100 - self.range["red"] - self.range["yellow"]:
258            self.canvas.itemconfig(self.canvas_objects.meter, fill=self._meter_yellow)
259            self.canvas.itemconfig(self.canvas_objects.meter, outline=self._meter_yellow)
260        else:
261            self.canvas.itemconfig(self.canvas_objects.meter, fill=self._meter_color)
262            self.canvas.itemconfig(self.canvas_objects.meter, outline=self._meter_color)
263        angle = (1 - pct) * Meter.EXTENT_ANGLE + Meter.START_ANGLE
264        self._update_meter_line(angle)
265
266    @classmethod
267    def _percent_to_degrees(cls, pct: float) -> float:
268        return float(Meter.EXTENT_ANGLE) * pct / 100
269
270    def set_value(self, value: float) -> None:
271        """
272        Set the value to display on the meter.
273        """
274        self.var.set(value)
275
276    def bind(self, sequence=None, func=None, add=None):  # noqa: ANN001,ANN201
277        """
278        Pass events through to the canvas, since frames don't normally respond to them.
279        """
280        return self.canvas.bind(sequence, func, add)