KL-Py 0.0.1__py3-none-any.whl

KL_Py/hindGui/elements/combo.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import tkinter as tk
+import tkinter.font
+from tkinter import ttk
+
+import hindGui
+from hindGui import COLOR_SYSTEM_DEFAULT
+from hindGui import ELEM_TYPE_INPUT_COMBO
+from hindGui import Element
+from hindGui import theme_button_color
+from hindGui._utils import _error_popup_with_traceback
+
+
+class Combo(Element):
+    """
+    ComboBox Element - A combination of a single-line input and a drop-down menu. User can type in their own value or choose from list.
+    """
+
+    def __init__(
+        self,
+        values,
+        chunawa=None,
+        size=(None, None),
+        s=(None, None),
+        auto_size_text=None,
+        background_color=None,
+        text_color=None,
+        button_background_color=None,
+        button_arrow_color=None,
+        bind_return_key=False,
+        change_submits=False,
+        enable_events=True,
+        enable_per_char_events=None,
+        disabled=False,
+        action=None,
+        k=None,
+        pad=None,
+        p=None,
+        expand_x=False,
+        expand_y=False,
+        ke_upar=None,
+        na_badla_jae=False,
+        font=None,
+        nazar=True,
+        metadata=None,
+    ):
+        """
+        :param values:                  values to choose. While displayed as text, the items returned are what the caller supplied, not text
+        :type values:                   List[Any] or Tuple[Any]
+        :param chunawa:           Choice to be displayed as initial value. Must match one of values variable contents
+        :type chunawa:            (Any)
+        :param size:                    width, height. Width = characters-wide, height = NOTE it's the number of entries to show in the list. If an Int is passed rather than a tuple, then height is auto-set to 1 and width is value of the int
+        :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:          True if element should be the same size as the contents
+        :type auto_size_text:           (bool)
+        :param background_color:        color of background
+        :type background_color:         (str)
+        :param text_color:              color of the text
+        :type text_color:               (str)
+        :param button_background_color: The color of the background of the button on the combo box
+        :type button_background_color:  (str)
+        :param button_arrow_color:      The color of the arrow on the button on the combo box
+        :type button_arrow_color:       (str)
+        :param bind_return_key:         If True, then the return action will cause a the Combo to generate an action when return action is pressed
+        :type bind_return_key:          (bool)
+        :param change_submits:          DEPRICATED DO NOT USE. Use `enable_events` instead
+        :type change_submits:           (bool)
+        :param enable_events:           Turns on the element specific events. Combo action is when a choice is made
+        :type enable_events:            (bool)
+        :param enable_per_char_events:  Enables generation of events for every character that's input. This is like the Input element's events
+        :type enable_per_char_events:   (bool)
+        :param disabled:                set disable state for element
+        :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 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 ke_upar:                 text that will appear when mouse hovers over this element
+        :type ke_upar:                  (str)
+        :param na_badla_jae:                make element na_badla_jae (user can't badlo). True means user cannot badlo
+        :type na_badla_jae:                 (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 nazar:                 set visibility state of the element
+        :type nazar:                  (bool)
+        :param metadata:                User metadata that can be set to ANYTHING
+        :type metadata:                 (Any)
+        """
+
+        self.Values = values
+        self.DefaultValue = chunawa
+        self.ChangeSubmits = change_submits or enable_events
+        self.Widget = self.TKCombo = None  # type: ttk.Combobox
+        self.Disabled = disabled
+        self.Readonly = na_badla_jae
+        self.BindReturnKey = bind_return_key
+        bg = background_color if background_color else hindGui.DEFAULT_INPUT_ELEMENTS_COLOR
+        fg = text_color if text_color is not None else hindGui.DEFAULT_INPUT_TEXT_COLOR
+        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
+        if button_background_color is None:
+            self.button_background_color = theme_button_color()[1]
+        else:
+            self.button_background_color = button_background_color
+        if button_arrow_color is None:
+            self.button_arrow_color = theme_button_color()[0]
+        else:
+            self.button_arrow_color = button_arrow_color
+        self.enable_per_char_events = enable_per_char_events
+
+        super().__init__(
+            ELEM_TYPE_INPUT_COMBO,
+            size=sz,
+            auto_size_text=auto_size_text,
+            background_color=bg,
+            text_color=fg,
+            action=action,
+            pad=pad,
+            ke_upar=ke_upar,
+            font=font or hindGui.DEFAULT_FONT,
+            nazar=nazar,
+            metadata=metadata,
+        )
+
+    def badlo(
+        self,
+        value=None,
+        values=None,
+        set_to_index=None,
+        disabled=None,
+        na_badla_jae=None,
+        font=None,
+        nazar=None,
+        size=(None, None),
+        select=None,
+        text_color=None,
+        background_color=None,
+    ):
+        """
+        Changes some of the settings for the Combo Element. Must call `Window.Read` or `Window.Finalize` prior.
+        Note that the state can be in 3 states only.... enabled, disabled, na_badla_jae even
+        though more combinations are available. The easy way to remember is that if you
+        badlo the na_badla_jae parameter then you are enabling the element.
+
+        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:            badlo which value is current selected based on new list of previous list of choices
+        :type value:             (Any)
+        :param values:           badlo list of choices
+        :type values:            List[Any]
+        :param set_to_index:     badlo selection to a particular choice starting with index = 0
+        :type set_to_index:      (int)
+        :param disabled:         disable or enable state of the element
+        :type disabled:          (bool)
+        :param na_badla_jae:         if True make element na_badla_jae (user cannot badlo any choices). Enables the element if either choice are made.
+        :type na_badla_jae:          (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 nazar:          control visibility of element
+        :type nazar:           (bool)
+        :param size:             width, height. Width = characters-wide, height = NOTE it's the number of entries to show in the list
+        :type size:              (int, int)
+        :param select:           if True, then the text will be selected, if False then selection will be cleared
+        :type select:            (bool)
+        :param background_color: color of background
+        :type background_color:  (str)
+        :param text_color:       color of the text
+        :type text_color:        (str)
+        """
+
+        if size != (None, None):
+            if isinstance(size, int):
+                size = (size, 1)
+            if isinstance(size, tuple) and len(size) == 1:
+                size = (size[0], 1)
+
+        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 Combo.badlo - The window was closed')
+            return
+
+        if values is not None:
+            try:
+                self.TKCombo['values'] = values
+                # self.TKCombo.current(0)       # don't set any value if a new set of values was made
+            except:
+                pass
+            self.Values = values
+            if value is None:
+                self.TKCombo.set('')
+            if size == (None, None):
+                max_line_len = max([len(str(line)) for line in self.Values]) if len(self.Values) else 0
+                if self.AutoSizeText is False:
+                    width = self.Size[0]
+                else:
+                    width = max_line_len + 1
+                self.TKCombo.configure(width=width)
+            else:
+                self.TKCombo.configure(height=size[1])
+                self.TKCombo.configure(width=size[0])
+        if value is not None:
+            if value not in self.Values:
+                self.TKCombo.set(value)
+            else:
+                for index, v in enumerate(self.Values):
+                    if v == value:
+                        try:
+                            self.TKCombo.current(index)
+                        except:
+                            pass
+                        self.DefaultValue = value
+                        break
+        if set_to_index is not None:
+            try:
+                self.TKCombo.current(set_to_index)
+                self.DefaultValue = self.Values[set_to_index]
+            except:
+                pass
+        if na_badla_jae:
+            self.Readonly = True
+            self.TKCombo['state'] = 'readonly'
+        elif na_badla_jae is False:
+            self.Readonly = False
+            self.TKCombo['state'] = 'enable'
+        if disabled is True:
+            self.TKCombo['state'] = 'disable'
+        elif disabled is False and self.Readonly is True:
+            self.TKCombo['state'] = 'readonly'
+        elif disabled is False and self.Readonly is False:
+            self.TKCombo['state'] = 'enable'
+        self.Disabled = disabled if disabled is not None else self.Disabled
+
+        combostyle = self.ttk_style
+        style_name = self.ttk_style_name
+        if text_color is not None:
+            combostyle.configure(style_name, foreground=text_color)
+            combostyle.configure(style_name, selectforeground=text_color)
+            combostyle.configure(style_name, insertcolor=text_color)
+            combostyle.map(style_name, fieldforeground=[('readonly', text_color)])
+            self.TextColor = text_color
+        if background_color is not None:
+            combostyle.configure(style_name, selectbackground=background_color)
+            combostyle.map(style_name, fieldbackground=[('readonly', background_color)])
+            combostyle.configure(style_name, fieldbackground=background_color)
+            self.BackgroundColor = background_color
+
+        if self.Readonly is True:
+            if text_color not in (None, COLOR_SYSTEM_DEFAULT):
+                combostyle.configure(style_name, selectforeground=text_color)
+            if background_color not in (None, COLOR_SYSTEM_DEFAULT):
+                combostyle.configure(style_name, selectbackground=background_color)
+
+        if font is not None:
+            self.Font = font
+            self.TKCombo.configure(font=font)
+            self._dropdown_newfont = tkinter.font.Font(font=font)
+            self.ParentRowFrame.option_add('*TCombobox*Listbox*Font', self._dropdown_newfont)
+
+        # make tcl call to deal with colors for the drop-down formatting
+        try:
+            if self.BackgroundColor not in (None, COLOR_SYSTEM_DEFAULT) and self.TextColor not in (
+                None,
+                COLOR_SYSTEM_DEFAULT,
+            ):
+                self.Widget.tk.eval(
+                    '[ttk::combobox::PopdownWindow {}].f.l configure -foreground {} -background {} -selectforeground {} -selectbackground {} -font {}'.format(
+                        self.Widget,
+                        self.TextColor,
+                        self.BackgroundColor,
+                        self.BackgroundColor,
+                        self.TextColor,
+                        self._dropdown_newfont,
+                    )
+                )
+        except Exception:
+            pass  # going to let this one slide
+
+        if nazar is False:
+            self._pack_forget_save_settings()
+            # self.TKCombo.pack_forget()
+        elif nazar is True:
+            self._pack_restore_settings()
+            # self.TKCombo.pack(padx=self.pad_used[0], pady=self.pad_used[1])
+        if nazar is not None:
+            self.nazar = nazar
+        if select is True:
+            self.TKCombo.select_range(0, tk.END)
+        elif select is False:
+            self.TKCombo.select_clear()
+
+    def get(self):
+        """
+        Returns the current (right now) value of the Combo.  DO NOT USE THIS AS THE NORMAL WAY OF READING A COMBO!
+        You should be using values from your call to window.read instead.  Know what you're doing if you use it.
+
+        :return: Returns the value of what is currently chosen
+        :rtype:  Any | None
+        """
+        try:
+            if self.TKCombo.current() == -1:  # if the current value was not in the original list
+                value = self.TKCombo.get()  # then get the value typed in by user
+            else:
+                value = self.Values[self.TKCombo.current()]  # get value from original list given index
+        except:
+            value = None  # only would happen if user closes window
+        return value
+
+    Get = get
+    Change = badlo

KL_Py/hindGui/elements/error.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from hindGui import ELEM_TYPE_ERROR
+from hindGui.elements.base import Element
+
+
+class ErrorElement(Element):
+    """
+    A "dummy Element" that is returned when there are error conditions, like trying to find an element that's invalid
+    """
+
+    def __init__(self, action=None, metadata=None):
+        """
+        :param action: Used with window.find_element and with return values to uniquely identify this element
+        :type action:
+        """
+        self.Key = action
+
+        super().__init__(ELEM_TYPE_ERROR, action=action, metadata=metadata)
+
+    def badlo(self, silent_on_error=True, *args, **kwargs):
+        """
+        Change method for the Error Element, an element that should not be directly used by developer
+
+        :param silent_on_error: if False, then a Popup window will be shown
+        :type silent_on_error:  (bool)
+        :param *args:           meant to "soak up" any normal parameters passed in
+        :type *args:            (Any)
+        :param **kwargs:        meant to "soak up" any keyword parameters that were passed in
+        :type **kwargs:         (Any)
+        :return:                returns 'self' so call can be chained
+        :rtype:                 (ErrorElement)
+        """
+        print('** Your badlo is being ignored because you supplied a bad action earlier **')
+        return self
+
+    def get(self):
+        """
+        One of the method names found in other Elements. Used here to return an error string in case it's called
+
+        :return: A warning text string.
+        :rtype:  (str)
+        """
+        return 'This is NOT a valid Element!\nSTOP trying to do things with it or I will have to crash at some point!'
+
+    Get = get
+    Change = badlo

KL_Py/hindGui/elements/frame.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import tkinter as tk
+import warnings
+
+import hindGui
+from hindGui import _random_error_emoji
+from hindGui import ELEM_TYPE_FRAME
+from hindGui import Element
+from hindGui import error
+from hindGui._utils import _error_popup_with_traceback
+from hindGui.window import Window
+
+
+class Frame(Element):
+    """
+    A Frame Element that contains other Elements. Encloses with a line around elements and a text label.
+    """
+
+    def __init__(
+        self,
+        title,
+        layout,
+        title_color=None,
+        background_color=None,
+        title_location=None,
+        relief=hindGui.DEFAULT_FRAME_RELIEF,
+        size=(None, None),
+        s=(None, None),
+        font=None,
+        pad=None,
+        p=None,
+        border_width=None,
+        action=None,
+        k=None,
+        ke_upar=None,
+        right_click_menu=None,
+        expand_x=False,
+        expand_y=False,
+        grab=None,
+        nazar=True,
+        element_justification='left',
+        vertical_alignment=None,
+        metadata=None,
+    ):
+        """
+        :param title:                 text that is displayed as the Frame's "label" or title
+        :type title:                  (str)
+        :param layout:                The layout to put inside the Frame
+        :type layout:                 List[List[Elements]]
+        :param title_color:           color of the title text
+        :type title_color:            (str)
+        :param background_color:      background color of the Frame
+        :type background_color:       (str)
+        :param title_location:        location to place the text title.  Choices include: TITLE_LOCATION_TOP TITLE_LOCATION_BOTTOM TITLE_LOCATION_LEFT TITLE_LOCATION_RIGHT TITLE_LOCATION_TOP_LEFT TITLE_LOCATION_TOP_RIGHT TITLE_LOCATION_BOTTOM_LEFT TITLE_LOCATION_BOTTOM_RIGHT
+        :type title_location:         (enum)
+        :param relief:                relief style. Values are same as other elements with reliefs. Choices include RELIEF_RAISED RELIEF_SUNKEN RELIEF_FLAT RELIEF_RIDGE RELIEF_GROOVE RELIEF_SOLID
+        :type relief:                 (enum)
+        :param size:                  (width, height) Sets an initial hard-coded size for the Frame. This used to be a problem, but was fixed in 4.53.0 and works better than Columns when using the size paramter
+        :type size:                   (int, 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 font:                  specifies the  font family, size, etc. for the TITLE. 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 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 border_width:          width of border around element in pixels
+        :type border_width:           (int)
+        :param action:                   Value that uniquely identifies this element from all other elements. Used when Finding an element or in return values. Must be unique to the window
+        :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 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 grab:                  If True can grab this element and move the window around. Default is False
+        :type grab:                   (bool)
+        :param visible:               set visibility state of the element
+        :type visible:                (bool)
+        :param element_justification: All elements inside the Frame will have this justification 'left', 'right', 'center' are valid values
+        :type element_justification:  (str)
+        :param vertical_alignment:    Place the Frame at the 'top', 'center', 'bottom' of the row (can also use t,c,r). Defaults to no setting (tkinter decides)
+        :type vertical_alignment:     (str)
+        :param metadata:              User metadata that can be set to ANYTHING
+        :type metadata:               (Any)
+        """
+
+        self.UseDictionary = False
+        self.ReturnValues = None
+        self.ReturnValuesList = []
+        self.ReturnValuesDictionary = {}
+        self.DictionaryKeyCounter = 0
+        self.ParentWindow = None
+        self.Rows = []
+        # self.ParentForm = None
+        self.TKFrame = None
+        self.Title = title
+        self.Relief = relief
+        self.TitleLocation = title_location
+        self.BorderWidth = border_width
+        self.BackgroundColor = background_color if background_color is not None else hindGui.DEFAULT_BACKGROUND_COLOR
+        self.RightClickMenu = right_click_menu
+        self.ContainerElemementNumber = Window._GetAContainerNumber()
+        self.ElementJustification = element_justification
+        self.VerticalAlignment = vertical_alignment
+        self.Widget = None  # type: tk.LabelFrame
+        self.Grab = grab
+        self.Layout(layout)
+        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_FRAME,
+            background_color=background_color,
+            text_color=title_color,
+            size=sz,
+            font=font,
+            pad=pad,
+            action=action,
+            ke_upar=ke_upar,
+            nazar=nazar,
+            metadata=metadata,
+        )
+        return
+
+    def add_row(self, *args):
+        """
+        Not recommended user call.  Used to add rows of Elements to the Frame Element.
+
+        :param *args: The list of elements for this row
+        :type *args:  List[Element]
+        """
+        NumRows = len(self.Rows)  # number of existing rows is our row number
+        CurrentRowNumber = NumRows  # this row's number
+        CurrentRow = []  # start with a blank row and build up
+        # -------------------------  Add the elements to a row  ------------------------- #
+        for i, element in enumerate(args):  # Loop through list of elements and add them to the row
+            if type(element) is list:
+                error(
+                    'Error creating Frame layout',
+                    'Layout has a LIST instead of an ELEMENT',
+                    'This sometimes means you have a badly placed ]',
+                    'The offensive list is:',
+                    element,
+                    'This list will be stripped from your layout',
+                    ehem=True,
+                )
+                continue
+            elif callable(element) and not isinstance(element, Element):
+                error(
+                    'Error creating Frame layout',
+                    'Layout has a FUNCTION instead of an ELEMENT',
+                    'This likely means you are missing () from your layout',
+                    'The offensive list is:',
+                    element,
+                    'This item will be stripped from your layout',
+                    ehem=True,
+                )
+                continue
+            if element.ParentContainer is not None:
+                warnings.warn(
+                    '*** YOU ARE ATTEMPTING TO REUSE AN ELEMENT IN YOUR LAYOUT! Once placed in a layout, an element cannot be used in another layout. ***',
+                    UserWarning,
+                )
+                _error_popup_with_traceback(
+                    'Error creating Frame layout',
+                    'The layout specified has already been used',
+                    'You MUST start witha "clean", unused layout every time you create a window',
+                    'The offensive Element = ',
+                    element,
+                    'and has a action = ',
+                    element.Event,
+                    'This item will be stripped from your layout',
+                    'Hint - try printing your layout and matching the IDs "print(layout)"',
+                )
+                continue
+            element.Position = (CurrentRowNumber, i)
+            element.ParentContainer = self
+            CurrentRow.append(element)
+            if element.Event is not None:
+                self.UseDictionary = True
+        # -------------------------  Append the row to list of Rows  ------------------------- #
+        self.Rows.append(CurrentRow)
+
+    def layout(self, rows):
+        """
+        Can use like the Window.Layout method, but it's better to use the layout parameter when creating
+
+        :param rows: The rows of Elements
+        :type rows:  List[List[Element]]
+        :return:     Used for chaining
+        :rtype:      (Frame)
+        """
+
+        for row in rows:
+            try:
+                iter(row)
+            except TypeError:
+                error(
+                    'Error creating Frame layout',
+                    'Your row is not an iterable (e.g. a list)',
+                    f'Instead of a list, the type found was {type(row)}',
+                    'The offensive row = ',
+                    row,
+                    'This item will be stripped from your layout',
+                    ehem=True,
+                    image=_random_error_emoji(),
+                )
+                continue
+            self.AddRow(*row)
+        return self
+
+    def _GetElementAtLocation(self, location):
+        """
+        Not user callable. Used to find the Element at a row, col position within the layout
+
+        :param location: (row, column) position of the element to find in layout
+        :type location:  (int, int)
+        :return:         (Element) The element found at the location
+        :rtype:          (Element)
+        """
+
+        (row_num, col_num) = location
+        row = self.Rows[row_num]
+        element = row[col_num]
+        return element
+
+    def badlo(self, value=None, nazar=None):
+        """
+        Changes some of the settings for the Frame Element. Must call `Window.Read` or `Window.Finalize` prior
+
+        Changes will not be visible 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 visible.
+
+        :param value:   New text value to show on frame
+        :type value:    (Any)
+        :param visible: control visibility of element
+        :type visible:  (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 Frame.badlo - The window was closed')
+            return
+
+        if nazar is False:
+            self._pack_forget_save_settings()
+            # self.TKFrame.pack_forget()
+        elif nazar is True:
+            self._pack_restore_settings()
+            # self.TKFrame.pack(padx=self.pad_used[0], pady=self.pad_used[1])
+        if value is not None:
+            self.TKFrame.config(text=str(value))
+        if nazar is not None:
+            self._nazar = nazar
+
+    AddRow = add_row
+    Layout = layout
+    Change = badlo