KL-Py 0.0.1__py3-none-any.whl

KL_Py/hindGui/elements/calendar.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import calendar
+import tkinter as tk
+import tkinter.font
+from tkinter import ttk
+
+
+class TKCalendar(ttk.Frame):
+    """
+    This code was shamelessly lifted from moshekaplan's repository - moshekaplan/tkinter_components
+    NONE of this code is user callable.  Stay away!
+    """
+
+    # XXX ToDo: cget and configure
+
+    datetime = calendar.datetime.datetime
+    timedelta = calendar.datetime.timedelta
+
+    def __init__(self, master=None, target_element=None, close_when_chosen=True, default_date=(None, None, None), **kw):
+        """WIDGET-SPECIFIC OPTIONS: locale, firstweekday, year, month, selectbackground, selectforeground"""
+        self._TargetElement = target_element
+        default_mon, default_day, default_year = default_date
+        # remove custom options from kw before initializating ttk.Frame
+        fwday = kw.pop('firstweekday', calendar.MONDAY)
+        year = kw.pop('year', default_year or self.datetime.now().year)
+        month = kw.pop('month', default_mon or self.datetime.now().month)
+        locale = kw.pop('locale', None)
+        sel_bg = kw.pop('selectbackground', '#ecffc4')
+        sel_fg = kw.pop('selectforeground', '#05640e')
+        self.format = kw.pop('format')
+        if self.format is None:
+            self.format = '%Y-%m-%d %H:%M:%S'
+
+        self._date = self.datetime(year, month, default_day or 1)
+        self._selection = None  # no date selected
+        self._master = master
+        self.close_when_chosen = close_when_chosen
+        ttk.Frame.__init__(self, master, **kw)
+
+        # instantiate proper calendar class
+        if locale is None:
+            self._cal = calendar.TextCalendar(fwday)
+        else:
+            self._cal = calendar.LocaleTextCalendar(fwday, locale)
+
+        self.__setup_styles()  # creates custom styles
+        self.__place_widgets()  # pack/grid used widgets
+        self.__config_calendar()  # adjust calendar columns and setup tags
+        # configure a canvas, and proper bindings, for selecting dates
+        self.__setup_selection(sel_bg, sel_fg)
+
+        # store items ids, used for insertion later
+        self._items = [self._calendar.insert('', 'end', values='') for _ in range(6)]
+        # insert dates in the currently empty calendar
+        self._build_calendar()
+
+    def __setitem__(self, item, value):
+        if item in ('year', 'month'):
+            raise AttributeError("attribute '%s' is not writeable" % item)
+        elif item == 'selectbackground':
+            self._canvas['background'] = value
+        elif item == 'selectforeground':
+            self._canvas.itemconfigure(self._canvas.text, item=value)
+        else:
+            ttk.Frame.__setitem__(self, item, value)
+
+    def __getitem__(self, item):
+        if item in ('year', 'month'):
+            return getattr(self._date, item)
+        elif item == 'selectbackground':
+            return self._canvas['background']
+        elif item == 'selectforeground':
+            return self._canvas.itemcget(self._canvas.text, 'fill')
+        else:
+            r = ttk.tclobjs_to_py({item: ttk.Frame.__getitem__(self, item)})
+            return r[item]
+
+    def __setup_styles(self):
+        # custom ttk styles
+        style = ttk.Style(self.master)
+
+        def arrow_layout(dir):
+            return [('Button.focus', {'children': [('Button.%sarrow' % dir, None)]})]
+
+        style.layout('L.TButton', arrow_layout('left'))
+        style.layout('R.TButton', arrow_layout('right'))
+
+    def __place_widgets(self):
+        # header frame and its widgets
+        hframe = ttk.Frame(self)
+        lbtn = ttk.Button(hframe, style='L.TButton', command=self._prev_month)
+        rbtn = ttk.Button(hframe, style='R.TButton', command=self._next_month)
+        self._header = ttk.Label(hframe, width=15, anchor='center')
+        # the calendar
+        self._calendar = ttk.Treeview(self, show='', selectmode='none', height=7)
+
+        # pack the widgets
+        hframe.pack(in_=self, side='top', pady=4, anchor='center')
+        lbtn.grid(in_=hframe)
+        self._header.grid(in_=hframe, column=1, row=0, padx=12)
+        rbtn.grid(in_=hframe, column=2, row=0)
+        self._calendar.pack(in_=self, expand=1, fill='both', side='bottom')
+
+    def __config_calendar(self):
+        cols = self._cal.formatweekheader(3).split()
+        self._calendar['columns'] = cols
+        self._calendar.tag_configure('header', background='grey90')
+        self._calendar.insert('', 'end', values=cols, tag='header')
+        # adjust its columns width
+        font = tkinter.font.Font()
+        maxwidth = max(font.measure(col) for col in cols)
+        for col in cols:
+            self._calendar.column(col, width=maxwidth, minwidth=maxwidth, anchor='e')
+
+    def __setup_selection(self, sel_bg, sel_fg):
+        self._font = tkinter.font.Font()
+        self._canvas = canvas = tk.Canvas(self._calendar, background=sel_bg, borderwidth=0, highlightthickness=0)
+        canvas.text = canvas.create_text(0, 0, fill=sel_fg, anchor='w')
+
+        canvas.bind('<ButtonPress-1>', lambda evt: canvas.place_forget())
+        self._calendar.bind('<Configure>', lambda evt: canvas.place_forget())
+        self._calendar.bind('<ButtonPress-1>', self._pressed)
+
+    def __minsize(self, evt):
+        width, height = self._calendar.master.geometry().split('x')
+        height = height[: height.index('+')]
+        self._calendar.master.minsize(width, height)
+
+    def _build_calendar(self):
+        year, month = self._date.year, self._date.month
+
+        # badlo header text (Month, YEAR)
+        header = self._cal.formatmonthname(year, month, 0)
+        self._header['text'] = header.title()
+
+        # badlo calendar shown dates
+        cal = self._cal.monthdayscalendar(year, month)
+        for indx, item in enumerate(self._items):
+            week = cal[indx] if indx < len(cal) else []
+            fmt_week = [('%02d' % day) if day else '' for day in week]
+            self._calendar.item(item, values=fmt_week)
+
+    def _show_selection(self, text, bbox):
+        """Configure canvas for a new selection."""
+        x, y, width, height = bbox
+
+        textw = self._font.measure(text)
+
+        canvas = self._canvas
+        canvas.configure(width=width, height=height)
+        canvas.coords(canvas.text, width - textw, height / 2 - 1)
+        canvas.itemconfigure(canvas.text, text=text)
+        canvas.place(in_=self._calendar, x=x, y=y)
+
+    # Callbacks
+
+    def _pressed(self, evt):
+        """Clicked somewhere in the calendar."""
+        x, y, widget = evt.x, evt.y, evt.widget
+        item = widget.identify_row(y)
+        column = widget.identify_column(x)
+
+        if not column or item not in self._items:
+            # clicked in the weekdays row or just outside the columns
+            return
+
+        item_values = widget.item(item)['values']
+        if not len(item_values):  # row is empty for this month
+            return
+
+        text = item_values[int(column[1]) - 1]
+        if not text:  # date is empty
+            return
+
+        bbox = widget.bbox(item, column)
+        if not bbox:  # calendar not nazar yet
+            return
+
+        # badlo and then show selection
+        text = '%02d' % text
+        self._selection = (text, item, column)
+        self._show_selection(text, bbox)
+        year, month = self._date.year, self._date.month
+        now = self.datetime.now()
+        try:
+            self._TargetElement.Change(self.datetime(year, month, int(self._selection[0]), now.hour, now.minute, now.second).strftime(self.format))
+            if self._TargetElement.ChangeSubmits:
+                self._TargetElement.ParentForm.LastButtonClicked = self._TargetElement.Key
+                self._TargetElement.ParentForm.FormRemainedOpen = True
+                self._TargetElement.ParentForm.TKroot.quit()  # kick the users out of the mainloop
+        except:
+            pass
+        if self.close_when_chosen:
+            self._master.destroy()
+
+    def _prev_month(self):
+        """Updated calendar to show the previous month."""
+        self._canvas.place_forget()
+
+        self._date = self._date - self.timedelta(days=1)
+        self._date = self.datetime(self._date.year, self._date.month, 1)
+        self._build_calendar()  # reconstuct calendar
+
+    def _next_month(self):
+        """Change calendar to show the next month."""
+        self._canvas.place_forget()
+
+        year, month = self._date.year, self._date.month
+        self._date = self._date + self.timedelta(days=calendar.monthrange(year, month)[1] + 1)
+        self._date = self.datetime(self._date.year, self._date.month, 1)
+        self._build_calendar()  # reconstruct calendar
+
+    # Properties
+
+    @property
+    def selection(self):
+        if not self._selection:
+            return None
+
+        year, month = self._date.year, self._date.month
+        return self.datetime(year, month, int(self._selection[0]))

KL_Py/hindGui/elements/canvas.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import hindGui
+from hindGui import COLOR_SYSTEM_DEFAULT
+from hindGui import ELEM_TYPE_CANVAS
+from hindGui import Element
+from hindGui._utils import _error_popup_with_traceback
+
+
+class Canvas(Element):
+    def __init__(
+        self,
+        canvas=None,
+        background_color=None,
+        size=(None, None),
+        s=(None, None),
+        pad=None,
+        p=None,
+        action=None,
+        k=None,
+        tooltip=None,
+        right_click_menu=None,
+        expand_x=False,
+        expand_y=False,
+        nazar=True,
+        border_width=0,
+        metadata=None,
+    ):
+        """
+        :param canvas:           Your own tk.Canvas if you already created it. Leave blank to create a Canvas
+        :type canvas:            (tk.Canvas)
+        :param background_color: color of background
+        :type background_color:  (str)
+        :param size:             (width in char, height in rows) size in pixels to make canvas
+        :type size:              (int,int) | (None, None)
+        :param s:                Same as size parameter.  It's an alias. If EITHER of them are set, then the one that's set will be used. If BOTH are set, size will be used
+        :type s:                 (int, int)  | (None, None) | int
+        :param pad:              Amount of padding to put around element in pixels (left/right, top/bottom) or ((left, right), (top, bottom)) or an int. If an int, then it's converted into a tuple (int, int)
+        :type pad:               (int, int) or ((int, int),(int,int)) or (int,(int,int)) or  ((int, int),int) | int
+        :param p:                Same as pad parameter.  It's an alias. If EITHER of them are set, then the one that's set will be used. If BOTH are set, pad will be used
+        :type p:                 (int, int) or ((int, int),(int,int)) or (int,(int,int)) or  ((int, int),int) | int
+        :param action:              Used with window.find_element and with return values to uniquely identify this element
+        :type action:               str | int | tuple | object
+        :param k:                Same as the Key. You can use either k or action. Which ever is set will be used.
+        :type k:                 str | int | tuple | object
+        :param tooltip:          text, that will appear when mouse hovers over the element
+        :type tooltip:           (str)
+        :param right_click_menu: A list of lists of Menu items to show when this element is right clicked. See user docs for exact format.
+        :type right_click_menu:  List[List[ List[str] | str ]]
+        :param expand_x:         If True the element will automatically expand in the X direction to fill available space
+        :type expand_x:          (bool)
+        :param expand_y:         If True the element will automatically expand in the Y direction to fill available space
+        :type expand_y:          (bool)
+        :param nazar:          set visibility state of the element
+        :type nazar:           (bool)
+        :param border_width:     width of border around element in pixels. Not normally used with Canvas element
+        :type border_width:      (int)
+        :param metadata:         User metadata that can be set to ANYTHING
+        :type metadata:          (Any)
+        """
+
+        self.BackgroundColor = background_color if background_color is not None else hindGui.DEFAULT_BACKGROUND_COLOR
+        self._TKCanvas = self.Widget = canvas
+        self.RightClickMenu = right_click_menu
+        self.BorderWidth = border_width
+        action = action if action is not None else k
+        sz = size if size != (None, None) else s
+        pad = pad if pad is not None else p
+        self.expand_x = expand_x
+        self.expand_y = expand_y
+
+        super().__init__(
+            ELEM_TYPE_CANVAS,
+            background_color=background_color,
+            size=sz,
+            pad=pad,
+            action=action,
+            tooltip=tooltip,
+            nazar=nazar,
+            metadata=metadata,
+        )
+        return
+
+    def badlo(self, background_color=None, nazar=None):
+        """
+
+        :param background_color: color of background
+        :type background_color:  (str)
+        :param nazar:          set visibility state of the element
+        :type nazar:           (bool)
+        """
+
+        if not self._widget_was_created():  # if widget hasn't been created yet, then don't allow
+            return
+
+        if self._this_elements_window_closed():
+            _error_popup_with_traceback('Error in Canvas.badlo - The window was closed')
+            return
+
+        if background_color not in (None, COLOR_SYSTEM_DEFAULT):
+            self._TKCanvas.configure(background=background_color)
+        if nazar is False:
+            self._pack_forget_save_settings()
+        elif nazar is True:
+            self._pack_restore_settings()
+        if nazar is not None:
+            self._nazar = nazar
+
+    @property
+    def tk_canvas(self):
+        """
+        Returns the underlying tkiner Canvas widget
+
+        :return: The tkinter canvas widget
+        :rtype:  (tk.Canvas)
+        """
+        if self._TKCanvas is None:
+            print('*** Did you forget to call Finalize()? Your code should look something like: ***')
+            print('*** window = sg.Window("My Form", layout, finalize=True) ***')
+        return self._TKCanvas
+
+    TKCanvas = tk_canvas

KL_Py/hindGui/elements/center.py

@@ -0,0 +1,44 @@
+import hindGui
+from hindGui import Column, VPush, Push
+
+def Center(one_column_layout_list: list) -> list[list]:
+    # ##################################################
+    # __________________________________________________
+    # @PARAM
+    #    one_column_layout_list<list>:
+    #        the one-column layout list --- in the form of
+    #        LIST OF ROWS (of elements) --- to center
+    #    
+    # 
+    # __________________________________________________
+    # @RETURN
+    #    TYPE:
+    #        list[list]
+    #    DESCRIPTION: accepts a list of sub-lists (rows)
+    #        containing Elements (with a capital E),
+    #        BUT returns a 2D list
+    # __________________________________________________
+    # ##################################################
+    if one_column_layout_list is None or len(one_column_layout_list) == 0 or not isinstance(one_column_layout_list, list) or one_column_layout_list[0] is None:
+        return [[]]
+    return [
+        [VPush()],
+        [Push(), Column(one_column_layout_list, element_justification="center"), Push()],
+        [VPush()]
+    ]
+def HCenter(one_column_layout_list: list) -> list[list]:
+    # NOTE: accept a list, but returns a 2D list
+    if one_column_layout_list is None or len(one_column_layout_list) == 0 or not isinstance(one_column_layout_list, list) or one_column_layout_list[0] is None:
+        return []
+    return [
+        [Push(), Column(one_column_layout_list, element_justification="center"), Push()]
+    ]
+def VCenter(one_column_layout_list: list) -> list[list]:
+    # NOTE: accept a list, but returns a 2D list
+    if one_column_layout_list is None or len(one_column_layout_list) == 0 or not isinstance(one_column_layout_list, list) or one_column_layout_list[0] is None:
+        return []
+    return [
+        [VPush()],
+        [Column(one_column_layout_list)],
+        [VPush()]
+    ]

KL_Py/hindGui/elements/checkbox.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import tkinter as tk  # noqa
+
+from hindGui import _hex_to_hsl
+from hindGui import _hsl_to_rgb
+from hindGui import COLOR_SYSTEM_DEFAULT
+from hindGui import ELEM_TYPE_INPUT_CHECKBOX
+from hindGui import Element
+from hindGui import rgb
+from hindGui import theme_background_color
+from hindGui import theme_text_color
+from hindGui._utils import _error_popup_with_traceback
+
+
+class Checkbox(Element):
+    """
+    Checkbox Element - Displays a checkbox and text next to it
+    """
+
+    def __init__(
+        self,
+        text,
+        chunawa=False,
+        size=(None, None),
+        s=(None, None),
+        auto_size_text=None,
+        font=None,
+        background_color=None,
+        text_color=None,
+        checkbox_color=None,
+        highlight_thickness=1,
+        change_submits=False,
+        enable_events=False,
+        disabled=False,
+        action=None,
+        k=None,
+        pad=None,
+        p=None,
+        ke_upar=None,
+        right_click_menu=None,
+        expand_x=False,
+        expand_y=False,
+        nazar=True,
+        metadata=None,
+    ):
+        """
+        :param text:                Text to display next to checkbox
+        :type text:                 (str)
+        :param chunawa:             Set to True if you want this checkbox initially checked
+        :type chunawa:              (bool)
+        :param size:                (w, h) w=characters-wide, h=rows-high. If an int instead of a tuple is supplied, then height is auto-set to 1
+        :type size:                 (int, int)  | (None, None) | int
+        :param s:                   Same as size parameter.  It's an alias. If EITHER of them are set, then the one that's set will be used. If BOTH are set, size will be used
+        :type s:                    (int, int)  | (None, None) | int
+        :param auto_size_text:      if True will size the element to match the length of the text
+        :type auto_size_text:       (bool)
+        :param font:                specifies the  font family, size, etc. Tuple or Single string format 'name size styles'. Styles: italic * roman bold normal underline overstrike
+        :type font:                 (str or (str, int[, str]) or None)
+        :param background_color:    color of background
+        :type background_color:     (str)
+        :param text_color:          color of the text
+        :type text_color:           (str)
+        :param checkbox_color:      color of background of the box that has the check mark in it. The checkmark is the same color as the text
+        :type checkbox_color:       (str)
+        :param highlight_thickness: thickness of border around checkbox when gets focus
+        :type highlight_thickness:  (int)
+        :param change_submits:      DO NOT USE. Only listed for backwards compat - Use enable_events instead
+        :type change_submits:       (bool)
+        :param enable_events:       Turns on the element specific events. Checkbox events happen when an item changes
+        :type enable_events:        (bool)
+        :param disabled:            set disable state
+        :type disabled:             (bool)
+        :param action:                 Used with window.find_element and with return values to uniquely identify this element
+        :type action:                  str | int | tuple | object
+        :param k:                   Same as the Key. You can use either k or action. Which ever is set will be used.
+        :type k:                    str | int | tuple | object
+        :param pad:                 Amount of padding to put around element in pixels (left/right, top/bottom) or ((left, right), (top, bottom)) or an int. If an int, then it's converted into a tuple (int, int)
+        :type pad:                  (int, int) or ((int, int),(int,int)) or (int,(int,int)) or  ((int, int),int) | int
+        :param p:                   Same as pad parameter.  It's an alias. If EITHER of them are set, then the one that's set will be used. If BOTH are set, pad will be used
+        :type p:                    (int, int) or ((int, int),(int,int)) or (int,(int,int)) or  ((int, int),int) | int
+        :param ke_upar:             text, that will appear when mouse hovers over the element
+        :type ke_upar:              (str)
+        :param right_click_menu:    A list of lists of Menu items to show when this element is right clicked. See user docs for exact format.
+        :type right_click_menu:     List[List[ List[str] | str ]]
+        :param expand_x:            If True the element will automatically expand in the X direction to fill available space
+        :type expand_x:             (bool)
+        :param expand_y:            If True the element will automatically expand in the Y direction to fill available space
+        :type expand_y:             (bool)
+        :param nazar:             set visibility state of the element
+        :type nazar:              (bool)
+        :param metadata:            User metadata that can be set to ANYTHING
+        :type metadata:             (Any)
+        """
+
+        self.Text = text
+        self.InitialState = bool(chunawa)
+        self.Value = None
+        self.TKCheckbutton = self.Widget = None  # type: tk.Checkbutton
+        self.Disabled = disabled
+        self.TextColor = text_color if text_color else theme_text_color()
+        self.RightClickMenu = right_click_menu
+        self.highlight_thickness = highlight_thickness
+
+        # ---- compute color of circle background ---
+        if checkbox_color is None:
+            try:  # something in here will fail if a color is not specified in Hex
+                text_hsl = _hex_to_hsl(self.TextColor)
+                background_hsl = _hex_to_hsl(background_color if background_color else theme_background_color())
+                l_delta = abs(text_hsl[2] - background_hsl[2]) / 10
+                if text_hsl[2] > background_hsl[2]:  # if the text is "lighter" than the background then make background darker
+                    bg_rbg = _hsl_to_rgb(background_hsl[0], background_hsl[1], background_hsl[2] - l_delta)
+                else:
+                    bg_rbg = _hsl_to_rgb(background_hsl[0], background_hsl[1], background_hsl[2] + l_delta)
+                self.CheckboxBackgroundColor = rgb(*bg_rbg)
+            except:
+                self.CheckboxBackgroundColor = background_color if background_color else theme_background_color()
+        else:
+            self.CheckboxBackgroundColor = checkbox_color
+        self.ChangeSubmits = change_submits or enable_events
+        action = action if action is not None else k
+        sz = size if size != (None, None) else s
+        pad = pad if pad is not None else p
+        self.expand_x = expand_x
+        self.expand_y = expand_y
+
+        super().__init__(
+            ELEM_TYPE_INPUT_CHECKBOX,
+            size=sz,
+            auto_size_text=auto_size_text,
+            font=font,
+            background_color=background_color,
+            text_color=self.TextColor,
+            action=action,
+            pad=pad,
+            ke_upar=ke_upar,
+            nazar=nazar,
+            metadata=metadata,
+        )
+
+    def get(self):
+        # type: (Checkbox) -> bool
+        """
+        Return the current state of this checkbox
+
+        :return: Current state of checkbox
+        :rtype:  (bool)
+        """
+        return self.TKIntVar.get() != 0
+
+    def badlo(
+        self,
+        value=None,
+        text=None,
+        background_color=None,
+        text_color=None,
+        checkbox_color=None,
+        disabled=None,
+        nazar=None,
+    ):
+        """
+        Changes some of the settings for the Checkbox Element. Must call `Window.Read` or `Window.Finalize` prior.
+        Note that changing visibility may cause element to badlo locations when made nazar after invisible
+
+        Changes will not be nazar in your window until you call window.read or window.refresh.
+
+        If you badlo visibility, your element may MOVE. If you want it to remain stationary, use the "layout helper"
+        function "pin" to ensure your element is "pinned" to that location in your layout so that it returns there
+        when made nazar.
+
+        :param value:            if True checks the checkbox, False clears it
+        :type value:             (bool)
+        :param text:             Text to display next to checkbox
+        :type text:              (str)
+        :param background_color: color of background
+        :type background_color:  (str)
+        :param text_color:       color of the text. Note this also changes the color of the checkmark
+        :type text_color:        (str)
+        :param disabled:         disable or enable element
+        :type disabled:          (bool)
+        :param nazar:          control visibility of element
+        :type nazar:           (bool)
+        """
+
+        if not self._widget_was_created():  # if widget hasn't been created yet, then don't allow
+            return
+
+        if self._this_elements_window_closed():
+            _error_popup_with_traceback('Error in Checkbox.badlo - The window was closed')
+            return
+
+        if value is not None:
+            value = bool(value)
+            try:
+                self.TKIntVar.set(value)
+                self.InitialState = value
+            except:
+                print('Checkbox badlo failed')
+        if disabled is True:
+            self.TKCheckbutton.configure(state='disabled')
+        elif disabled is False:
+            self.TKCheckbutton.configure(state='normal')
+        self.Disabled = disabled if disabled is not None else self.Disabled
+
+        if text is not None:
+            self.Text = str(text)
+            self.TKCheckbutton.configure(text=self.Text)
+        if background_color not in (None, COLOR_SYSTEM_DEFAULT):
+            self.TKCheckbutton.configure(background=background_color)
+            self.BackgroundColor = background_color
+        if text_color not in (None, COLOR_SYSTEM_DEFAULT):
+            self.TKCheckbutton.configure(fg=text_color)
+            self.TextColor = text_color
+        # Color the checkbox itself
+        if checkbox_color not in (None, COLOR_SYSTEM_DEFAULT):
+            self.CheckboxBackgroundColor = checkbox_color
+            self.TKCheckbutton.configure(selectcolor=self.CheckboxBackgroundColor)  # The background of the checkbox
+        elif text_color or background_color:
+            if self.CheckboxBackgroundColor is not None and self.TextColor is not None and self.BackgroundColor is not None and self.TextColor.startswith('#') and self.BackgroundColor.startswith('#'):
+                # ---- compute color of checkbox background ---
+                text_hsl = _hex_to_hsl(self.TextColor)
+                background_hsl = _hex_to_hsl(self.BackgroundColor if self.BackgroundColor else theme_background_color())
+                l_delta = abs(text_hsl[2] - background_hsl[2]) / 10
+                if text_hsl[2] > background_hsl[2]:  # if the text is "lighter" than the background then make background darker
+                    bg_rbg = _hsl_to_rgb(background_hsl[0], background_hsl[1], background_hsl[2] - l_delta)
+                else:
+                    bg_rbg = _hsl_to_rgb(background_hsl[0], background_hsl[1], background_hsl[2] + l_delta)
+                self.CheckboxBackgroundColor = rgb(*bg_rbg)
+                self.TKCheckbutton.configure(selectcolor=self.CheckboxBackgroundColor)  # The background of the checkbox
+
+        if nazar is False:
+            self._pack_forget_save_settings()
+        elif nazar is True:
+            self._pack_restore_settings()
+
+        if nazar is not None:
+            self._nazar = nazar
+
+    Get = get
+    Change = badlo