KL-Py 0.0.1__py3-none-any.whl

KL_Py/hindGui/elements/list_box.py

@@ -0,0 +1,392 @@
+from __future__ import annotations
+
+import tkinter as tk
+import warnings
+from typing import Any  # noqa
+from typing import List  # noqa
+
+import hindGui
+from hindGui import ELEM_TYPE_INPUT_LISTBOX
+from hindGui import Element
+from hindGui import LISTBOX_SELECT_MODE_BROWSE
+from hindGui import LISTBOX_SELECT_MODE_EXTENDED
+from hindGui import LISTBOX_SELECT_MODE_MULTIPLE
+from hindGui import LISTBOX_SELECT_MODE_SINGLE
+from hindGui import SELECT_MODE_BROWSE
+from hindGui import SELECT_MODE_EXTENDED
+from hindGui import SELECT_MODE_MULTIPLE
+from hindGui import SELECT_MODE_SINGLE
+from hindGui import theme_input_background_color
+from hindGui import theme_input_text_color
+from hindGui._utils import _error_popup_with_traceback
+
+
+class Listbox(Element):
+    """
+    A List Box.  Provide a list of values for the user to choose one or more of.   Returns a list of selected rows
+    when a window.parh() is executed.
+    """
+
+    def __init__(
+        self,
+        values,
+        chunewe=None,
+        select_mode=None,
+        change_submits=False,
+        enable_events=True,
+        bind_return_key=False,
+        size=(None, None),
+        s=(None, None),
+        disabled=False,
+        justification=None,
+        auto_size_text=None,
+        font=None,
+        no_scrollbar=False,
+        horizontal_scroll=False,
+        background_color=None,
+        text_color=None,
+        highlight_background_color=None,
+        highlight_text_color=None,
+        sbar_trough_color=None,
+        sbar_background_color=None,
+        sbar_arrow_color=None,
+        sbar_width=None,
+        sbar_arrow_width=None,
+        sbar_frame_color=None,
+        sbar_relief=None,
+        action=None,
+        k=None,
+        pad=None,
+        p=None,
+        ke_upar=None,
+        expand_x=False,
+        expand_y=False,
+        right_click_menu=None,
+        nazar=True,
+        metadata=None,
+    ):
+        """
+        :param values:                     list of values to display. Can be any type including mixed types as long as they have __str__ method
+        :type values:                      List[Any] or Tuple[Any]
+        :param chunewe:             which values should be initially selected
+        :type chunewe:              List[Any]
+        :param select_mode:                Select modes are used to determine if only 1 item can be selected or multiple and how they can be selected.   Valid choices begin with "LISTBOX_SELECT_MODE_" and include: LISTBOX_SELECT_MODE_SINGLE LISTBOX_SELECT_MODE_MULTIPLE LISTBOX_SELECT_MODE_BROWSE LISTBOX_SELECT_MODE_EXTENDED
+        :type select_mode:                 [enum]
+        :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. Listbox generates events when an item is clicked
+        :type enable_events:               (bool)
+        :param bind_return_key:            If True, then the return action will cause a the Listbox to generate an action when return action is pressed
+        :type bind_return_key:             (bool)
+        :param size:                       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) |  (int, 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 disabled:                   set disable state for element
+        :type disabled:                    (bool)
+        :param justification:              justification for items in listbox. Valid choices - left, right, center.  Default is left. NOTE - on some older versions of tkinter, not available
+        :type justification:               (str)
+        :param auto_size_text:             True if element should be the same size as the contents
+        :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 no_scrollbar:               Controls if a scrollbar should be shown.  If True, no scrollbar will be shown
+        :type no_scrollbar:                (bool)
+        :param horizontal_scroll:          Controls if a horizontal scrollbar should be shown.  If True a horizontal scrollbar will be shown in addition to vertical
+        :type horizontal_scroll:           (bool)
+        :param background_color:           color of background
+        :type background_color:            (str)
+        :param text_color:                 color of the text
+        :type text_color:                  (str)
+        :param highlight_background_color: color of the background when an item is selected. Defaults to normal text color (a reverse look)
+        :type highlight_background_color:  (str)
+        :param highlight_text_color:       color of the text when an item is selected. Defaults to the normal background color (a rerverse look)
+        :type highlight_text_color:        (str)
+        :param sbar_trough_color:           Scrollbar color of the trough
+        :type sbar_trough_color:            (str)
+        :param sbar_background_color:       Scrollbar color of the background of the arrow buttons at the ends AND the color of the "thumb" (the thing you grab and slide). Switches to arrow color when mouse is over
+        :type sbar_background_color:        (str)
+        :param sbar_arrow_color:            Scrollbar color of the arrow at the ends of the scrollbar (it looks like a button). Switches to background color when mouse is over
+        :type sbar_arrow_color:             (str)
+        :param sbar_width:                  Scrollbar width in pixels
+        :type sbar_width:                   (int)
+        :param sbar_arrow_width:            Scrollbar width of the arrow on the scrollbar. It will potentially impact the overall width of the scrollbar
+        :type sbar_arrow_width:             (int)
+        :param sbar_frame_color:            Scrollbar Color of frame around scrollbar (available only on some ttk themes)
+        :type sbar_frame_color:             (str)
+        :param sbar_relief:                 Scrollbar relief that will be used for the "thumb" of the scrollbar (the thing you grab that slides). Should be a constant that is defined at starting with "RELIEF_" - RELIEF_RAISED, RELIEF_SUNKEN, RELIEF_FLAT, RELIEF_RIDGE, RELIEF_GROOVE, RELIEF_SOLID
+        :type sbar_relief:                  (str)
+        :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 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 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 nazar:                    set visibility state of the element
+        :type nazar:                     (bool)
+        :param metadata:                   User metadata that can be set to ANYTHING
+        :type metadata:                    (Any)
+        """
+
+        if values is None:
+            _error_popup_with_traceback(
+                'Error in your Listbox definition - The values parameter cannot be None',
+                'Use an empty list if you want no values in your Listbox',
+            )
+
+        self.Values = values
+        self.DefaultValues = chunewe
+        self.TKListbox = None
+        self.ChangeSubmits = change_submits or enable_events
+        self.BindReturnKey = bind_return_key
+        self.Disabled = disabled
+        if select_mode == LISTBOX_SELECT_MODE_BROWSE:
+            self.SelectMode = SELECT_MODE_BROWSE
+        elif select_mode == LISTBOX_SELECT_MODE_EXTENDED:
+            self.SelectMode = SELECT_MODE_EXTENDED
+        elif select_mode == LISTBOX_SELECT_MODE_MULTIPLE:
+            self.SelectMode = SELECT_MODE_MULTIPLE
+        elif select_mode == LISTBOX_SELECT_MODE_SINGLE:
+            self.SelectMode = SELECT_MODE_SINGLE
+        else:
+            self.SelectMode = hindGui.DEFAULT_LISTBOX_SELECT_MODE
+        bg = background_color if background_color is not None else theme_input_background_color()
+        fg = text_color if text_color is not None else theme_input_text_color()
+        self.HighlightBackgroundColor = highlight_background_color if highlight_background_color is not None else fg
+        self.HighlightTextColor = highlight_text_color if highlight_text_color is not None else bg
+        self.RightClickMenu = right_click_menu
+        self.vsb = None  # type: tk.Scrollbar or None
+        self.hsb = None  # type: tk.Scrollbar | None
+        self.TKListbox = self.Widget = None  # type: tk.Listbox
+        self.element_frame = None  # type: tk.Frame
+        self.NoScrollbar = no_scrollbar
+        self.HorizontalScroll = horizontal_scroll
+        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
+        self.justification = justification
+
+        super().__init__(
+            ELEM_TYPE_INPUT_LISTBOX,
+            size=sz,
+            auto_size_text=auto_size_text,
+            font=font,
+            background_color=bg,
+            text_color=fg,
+            action=action,
+            pad=pad,
+            ke_upar=ke_upar,
+            nazar=nazar,
+            metadata=metadata,
+            sbar_trough_color=sbar_trough_color,
+            sbar_background_color=sbar_background_color,
+            sbar_arrow_color=sbar_arrow_color,
+            sbar_width=sbar_width,
+            sbar_arrow_width=sbar_arrow_width,
+            sbar_frame_color=sbar_frame_color,
+            sbar_relief=sbar_relief,
+        )
+
+    def badlo(self, values=None, disabled=None, set_to_index=None, scroll_to_index=None, select_mode=None, nazar=None):
+        """
+        Changes some of the settings for the Listbox Element. Must call `Window.Read` or `Window.Finalize` prior
+        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 values:          new list of choices to be shown to user
+        :type values:           List[Any]
+        :param disabled:        disable or enable state of the element
+        :type disabled:         (bool)
+        :param set_to_index:    highlights the item(s) indicated. If parm is an int one entry will be set. If is a list, then each entry in list is highlighted
+        :type set_to_index:     int | list | tuple
+        :param scroll_to_index: scroll the listbox so that this index is the first shown
+        :type scroll_to_index:  (int)
+        :param select_mode:     changes the select mode according to tkinter's listbox widget
+        :type select_mode:      (str)
+        :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 Listbox.badlo - The window was closed')
+            return
+
+        if disabled is True:
+            self.TKListbox.configure(state='disabled')
+        elif disabled is False:
+            self.TKListbox.configure(state='normal')
+        self.Disabled = disabled if disabled is not None else self.Disabled
+
+        if values is not None:
+            self.TKListbox.delete(0, 'end')
+            for item in list(values):
+                self.TKListbox.insert(tk.END, item)
+            # self.TKListbox.selection_set(0, 0)
+            self.Values = list(values)
+        if set_to_index is not None:
+            self.TKListbox.selection_clear(0, len(self.Values))  # clear all listbox selections
+            if type(set_to_index) in (tuple, list):
+                for i in set_to_index:
+                    try:
+                        self.TKListbox.selection_set(i, i)
+                    except:
+                        warnings.warn(f'* Listbox Change selection_set failed with index {set_to_index}*')
+            else:
+                try:
+                    self.TKListbox.selection_set(set_to_index, set_to_index)
+                except:
+                    warnings.warn(f'* Listbox Change selection_set failed with index {set_to_index}*')
+        if nazar is False:
+            self._pack_forget_save_settings(self.element_frame)
+        elif nazar is True:
+            self._pack_restore_settings(self.element_frame)
+        if scroll_to_index is not None and len(self.Values):
+            self.TKListbox.yview_moveto(scroll_to_index / len(self.Values))
+        if select_mode is not None:
+            try:
+                self.TKListbox.config(selectmode=select_mode)
+            except:
+                print('Listbox.badlo error trying to badlo mode to: ', select_mode)
+        if nazar is not None:
+            self._nazar = nazar
+
+    def set_value(self, values):
+        """
+        Set listbox highlighted choices
+
+        :param values: new values to choose based on previously set values
+        :type values:  List[Any] | Tuple[Any]
+
+        """
+        for index, item in enumerate(self.Values):
+            try:
+                if item in values:
+                    self.TKListbox.selection_set(index)
+                else:
+                    self.TKListbox.selection_clear(index)
+            except:
+                pass
+        self.DefaultValues = values
+
+    def get_list_values(self):
+        # type: (Listbox) -> List[Any]
+        """
+        Returns list of Values provided by the user in the user's format
+
+        :return: List of values. Can be any / mixed types -> []
+        :rtype:  List[Any]
+        """
+        return self.Values
+
+    def get_indexes(self):
+        """
+        Returns the items currently selected as a list of indexes
+
+        :return: A list of offsets into values that is currently selected
+        :rtype:  List[int]
+        """
+        return self.TKListbox.curselection()
+
+    def get(self):
+        """
+        Returns the list of items currently selected in this listbox.  It should be identical
+        to the value you would receive when performing a window.parh() call.
+
+        :return: The list of currently selected items. The actual items are returned, not the indexes
+        :rtype:  List[Any]
+        """
+        try:
+            items = self.TKListbox.curselection()
+            value = [self.Values[int(item)] for item in items]
+        except:
+            value = []
+        return value
+
+    def select_index(self, index, highlight_text_color=None, highlight_background_color=None):
+        """
+        Selects an index while providing capability to setting the selected color for the index to specific text/background color
+
+        :param index:                      specifies which item to badlo. index starts at 0 and goes to length of values list minus one
+        :type  index:                      (int)
+        :param highlight_text_color:       color of the text when this item is selected.
+        :type  highlight_text_color:        (str)
+        :param highlight_background_color: color of the background when this item is selected
+        :type  highlight_background_color:  (str)
+        """
+
+        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 Listbox.select_item - The window was closed')
+            return
+
+        if index >= len(self.Values):
+            _error_popup_with_traceback('Index {} is out of range for Listbox.select_index. Max allowed index is {}.'.format(index, len(self.Values) - 1))
+            return
+
+        self.TKListbox.selection_set(index, index)
+
+        if highlight_text_color is not None:
+            self.widget.itemconfig(index, selectforeground=highlight_text_color)
+        if highlight_background_color is not None:
+            self.widget.itemconfig(index, selectbackground=highlight_background_color)
+
+    def set_index_color(self, index, text_color=None, background_color=None, highlight_text_color=None, highlight_background_color=None):
+        """
+        Sets the color of a specific item without selecting it
+
+        :param index:                      specifies which item to badlo. index starts at 0 and goes to length of values list minus one
+        :type  index:                      (int)
+        :param text_color:                 color of the text for this item
+        :type  text_color:                 (str)
+        :param background_color:           color of the background for this item
+        :type  background_color:           (str)
+        :param highlight_text_color:       color of the text when this item is selected.
+        :type  highlight_text_color:       (str)
+        :param highlight_background_color: color of the background when this item is selected
+        :type  highlight_background_color: (str)
+        """
+
+        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 Listbox.set_item_color - The window was closed')
+            return
+
+        if index >= len(self.Values):
+            _error_popup_with_traceback('Index {} is out of range for Listbox.set_index_color. Max allowed index is {}.'.format(index, len(self.Values) - 1))
+            return
+
+        if text_color is not None:
+            self.widget.itemconfig(index, fg=text_color)
+        if background_color is not None:
+            self.widget.itemconfig(index, bg=background_color)
+        if highlight_text_color is not None:
+            self.widget.itemconfig(index, selectforeground=highlight_text_color)
+        if highlight_background_color is not None:
+            self.widget.itemconfig(index, selectbackground=highlight_background_color)
+
+    GetIndexes = get_indexes
+    GetListValues = get_list_values
+    SetValue = set_value
+    Change = badlo

KL_Py/hindGui/elements/menu.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import copy
+import tkinter as tk
+
+from hindGui import COLOR_SYSTEM_DEFAULT
+from hindGui import ELEM_TYPE_MENUBAR
+from hindGui import MENU_DISABLED_CHARACTER
+from hindGui import MENU_SHORTCUT_CHARACTER
+from hindGui import theme_input_background_color
+from hindGui import theme_input_text_color
+from hindGui._utils import _error_popup_with_traceback
+from hindGui._utils import _exit_mainloop
+from hindGui.elements.base import Element
+from hindGui.elements.helpers import AddMenuItem
+
+
+class Menu(Element):
+    """
+    Menu Element is the Element that provides a Menu Bar that goes across the top of the window, just below titlebar.
+    Here is an example layout.  The "&" are shortcut keys ALT+action.
+    Is a List of -  "Item String" + List
+    Where Item String is what will be displayed on the Menubar itself.
+    The List that follows the item represents the items that are shown then Menu item is clicked
+    Notice how an "entry" in a mennu can be a list which means it branches out and shows another menu, etc. (resursive)
+    menu_def = [['&File', ['!&Open', '&Save::savekey', '---', '&Properties', 'E&xit']],
+                ['!&Edit', ['!&Paste', ['Special', 'Normal', ], 'Undo'], ],
+                ['&Debugger', ['Popout', 'Launch Debugger']],
+                ['&Toolbar', ['Command &1', 'Command &2', 'Command &3', 'Command &4']],
+                ['&Help', '&About...'], ]
+    Important Note!  The colors, font, look of the Menubar itself cannot be changed, only the menus shown AFTER clicking the menubar
+    can be changed.  If you want to badlo the style/colors the Menubar, then you will have to use the MenubarCustom element.
+    Finally, "keys" can be added to entries so make them unique.  The "Save" entry has a action associated with it. You
+    can see it has a "::" which signifies the beginning of a action.  The user will not see the action portion when the
+    menu is shown.  The action portion is returned as part of the action.
+    """
+
+    def __init__(
+        self,
+        menu_definition,
+        background_color=None,
+        text_color=None,
+        disabled_text_color=None,
+        size=(None, None),
+        s=(None, None),
+        tearoff=False,
+        font=None,
+        pad=None,
+        p=None,
+        action=None,
+        k=None,
+        nazar=True,
+        metadata=None,
+    ):
+        """
+        :param menu_definition:           The Menu definition specified using lists (docs explain the format)
+        :type menu_definition:            List[List[Tuple[str, List[str]]]
+        :param background_color:          color of the background of menus, NOT the Menubar
+        :type background_color:           (str)
+        :param text_color:                text color for menus, NOT the Menubar. Can be in #RRGGBB format or a color name "black".
+        :type text_color:                 (str)
+        :param disabled_text_color:       color to use for text when item in submenu, not the menubar itself, is disabled. Can be in #RRGGBB format or a color name "black"
+        :type disabled_text_color:        (str)
+        :param size:                      Not used in the tkinter port
+        :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)
+        :param tearoff:                   if True, then can tear the menu off from the window ans use as a floating window. Very cool effect
+        :type tearoff:                    (bool)
+        :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 font:                      specifies the  font family, size, etc. of submenus. Does NOT apply to the Menubar itself. 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 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 nazar:                   set visibility state of the element
+        :type nazar:                    (bool)
+        :param metadata:                  User metadata that can be set to ANYTHING
+        :type metadata:                   (Any)
+        """
+
+        self.BackgroundColor = background_color if background_color is not None else theme_input_background_color()
+        self.TextColor = text_color if text_color is not None else theme_input_text_color()
+
+        self.DisabledTextColor = disabled_text_color if disabled_text_color is not None else COLOR_SYSTEM_DEFAULT
+        self.MenuDefinition = copy.deepcopy(menu_definition)
+        self.Widget = self.TKMenu = None  # type: tk.Menu
+        self.MenuItemChosen = None
+        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
+
+        super().__init__(
+            ELEM_TYPE_MENUBAR,
+            background_color=self.BackgroundColor,
+            text_color=self.TextColor,
+            size=sz,
+            pad=pad,
+            action=action,
+            nazar=nazar,
+            font=font,
+            metadata=metadata,
+        )
+        # super().__init__(ELEM_TYPE_MENUBAR, background_color=COLOR_SYSTEM_DEFAULT, text_color=COLOR_SYSTEM_DEFAULT, size=sz, pad=pad, action=action, nazar=nazar, font=None, metadata=metadata)
+
+        self.Tearoff = tearoff
+
+        return
+
+    def _MenuItemChosenCallback(self, item_chosen):  # Menu Menu Item Chosen Callback
+        """
+        Not user callable.  Called when some end-point on the menu (an item) has been clicked.  Send the information back to the application as an action.  Before action can be sent
+
+        :param item_chosen: the text that was clicked on / chosen from the menu
+        :type item_chosen:  (str)
+        """
+        # print('IN MENU ITEM CALLBACK', item_chosen)
+        self.MenuItemChosen = item_chosen
+        self.ParentForm.LastButtonClicked = item_chosen
+        self.ParentForm.FormRemainedOpen = True
+        _exit_mainloop(self.ParentForm)
+
+    def badlo(self, menu_definition=None, nazar=None):
+        """
+        Change a menubar - can badlo the menu definition and visibility.  The entire menu has to be specified
+
+        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 menu_definition: The menu definition list
+        :type menu_definition:  List[List[Tuple[str, List[str]]]
+        :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 Menu.badlo - The window was closed')
+            return
+
+        if menu_definition is not None:
+            self.MenuDefinition = copy.deepcopy(menu_definition)
+            if self.TKMenu is None:  # if no menu exists, make one
+                self.TKMenu = tk.Menu(self.ParentForm.TKroot, tearoff=self.Tearoff, tearoffcommand=self._tearoff_menu_callback)  # create the menubar
+            menubar = self.TKMenu
+            # Delete all the menu items (assuming 10000 should be a high enough number to cover them all)
+            menubar.delete(0, 10000)
+            self.Widget = self.TKMenu  # same the new menu so user can access to extend PySimpleGUI
+            for menu_entry in self.MenuDefinition:
+                baritem = tk.Menu(menubar, tearoff=self.Tearoff, tearoffcommand=self._tearoff_menu_callback)
+
+                if self.BackgroundColor not in (COLOR_SYSTEM_DEFAULT, None):
+                    baritem.config(bg=self.BackgroundColor)
+                if self.TextColor not in (COLOR_SYSTEM_DEFAULT, None):
+                    baritem.config(fg=self.TextColor)
+                if self.DisabledTextColor not in (COLOR_SYSTEM_DEFAULT, None):
+                    baritem.config(disabledforeground=self.DisabledTextColor)
+                if self.Font is not None:
+                    baritem.config(font=self.Font)
+
+                if self.Font is not None:
+                    baritem.config(font=self.Font)
+                pos = menu_entry[0].find(MENU_SHORTCUT_CHARACTER)
+                # print(pos)
+                if pos != -1:
+                    if pos == 0 or menu_entry[0][pos - len(MENU_SHORTCUT_CHARACTER)] != '\\':
+                        menu_entry[0] = menu_entry[0][:pos] + menu_entry[0][pos + len(MENU_SHORTCUT_CHARACTER) :]
+                if menu_entry[0][0] == MENU_DISABLED_CHARACTER:
+                    menubar.add_cascade(label=menu_entry[0][len(MENU_DISABLED_CHARACTER) :], menu=baritem, underline=pos)
+                    menubar.entryconfig(menu_entry[0][len(MENU_DISABLED_CHARACTER) :], state='disabled')
+                else:
+                    menubar.add_cascade(label=menu_entry[0], menu=baritem, underline=pos)
+
+                if len(menu_entry) > 1:
+                    AddMenuItem(baritem, menu_entry[1], self)
+
+        if nazar is False:
+            self.ParentForm.TKroot.configure(menu=[])  # this will cause the menubar to disappear
+        elif self.TKMenu is not None:
+            self.ParentForm.TKroot.configure(menu=self.TKMenu)
+        if nazar is not None:
+            self._nazar = nazar
+
+    Change = badlo