SwiftGUI 0.11.19__tar.gz → 0.11.20__tar.gz

{swiftgui-0.11.19 → swiftgui-0.11.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SwiftGUI
-Version: 0.11.19
+Version: 0.11.20
 Summary: An easy-to-use package for quickly creating smaller and bigger GUIs
 License-Expression: Apache-2.0
 License-File: LICENSE

{swiftgui-0.11.19 → swiftgui-0.11.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "SwiftGUI"
-version = "0.11.19"
+version = "0.11.20"
 packages = [
     { include = "SwiftGUI", from = "src" }
 ]

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Base.py

@@ -1,10 +1,9 @@
-from collections.abc import Iterable, Callable
 from functools import wraps
-from typing import Literal, Union, Any, Hashable, Protocol
+from typing import Literal, Union, Any, Hashable, Protocol, Iterable, Callable, TypeVar
 from SwiftGUI.Compat import Self
 import tkinter as tk
 
-from SwiftGUI import Event, GlobalOptions, Color, remove_None_vals, Literals, ReuseError, RowTypeError
+from SwiftGUI import Event, GlobalOptions, Color, remove_None_vals, Literals, ReuseError, RowTypeError, Tooltips
 from SwiftGUI.ElementFlags import ElementFlag
 #from SwiftGUI.Widget_Elements.Frame import Frame
 
@@ -52,6 +51,7 @@ class _BaseSharedAttributes:
     key: Hashable = None  # If given, this will be written to the event-value. Elements without a key can not throw key-events
     _key_function: Callable | Iterable[Callable] = None  # Saves the key-function(s), if given
 
+same_class = TypeVar("same_class")
 class BaseElement(_BaseSharedAttributes):
     """
     Base for every element and widget.
@@ -383,6 +383,52 @@ class BaseElement(_BaseSharedAttributes):
 
         return self
 
+    _tooltip_text: str | None = None
+    _bound_tooltip_functions: bool = False  # True, if the events for tooltips are already bound
+    @run_after_window_creation
+    def set_tooltip(self, text: str | None = None) -> Self:
+        """
+        Add/Change/Remove a tooltip from this element.
+
+        Set it to None to deactivate tooltips for this element
+
+        :param text: Text for the tooltip to show
+        :return:
+        """
+        self._tooltip_text = text
+
+        if not self._bound_tooltip_functions:
+            self._bound_tooltip_functions = True
+            aw = self.window.actual_window
+            aw.activate_tooltips()
+            self.bind_event(
+                "Enter",
+                key_function=Tooltips.mouse_entered_elem_callback,
+            ).bind_event(
+                "Leave",
+                key_function=Tooltips.mouse_exited_elem_callback,
+            )
+
+    @property
+    def tooltip_text(self) -> str | None:
+        return self._tooltip_text
+
+    @tooltip_text.setter
+    def tooltip_text(self, text: str | None):
+        self.set_tooltip(text)
+
+    @classmethod
+    def with_go(cls: type[same_class], go_class: type[GlobalOptions.DEFAULT_OPTIONS_CLASS]) -> type[same_class]:
+        """
+        Create this element with a different global-option-class
+        :param go_class: The global-option-class this object should apply
+        :return:
+        """
+        class Modified(cls):
+            defaults = go_class
+
+        return Modified
+
 class BaseWidget(BaseElement):
     """
     Base for every Widget

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Canvas_Elements/Text.py

@@ -89,7 +89,7 @@ class Text(Canvas_Elements.BaseCanvasElement):
         new_font = font.Font(
             self.canvas.tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Combined_Elements/BaseCombinedElement.py

@@ -43,6 +43,7 @@ class BaseCombinedElement(MixinElementWithDefaultEvent, BaseElement):
             frame = layout
         else:
             frame = Frame(layout)
+        self.frame = frame
 
         if internal_key_system:
             self._has_sublayout = True
@@ -233,3 +234,8 @@ class BaseCombinedElement(MixinElementWithDefaultEvent, BaseElement):
             self.set_value(val)
 
         return self
+
+    def _bind_event_to_widget(self, tk_event: str, event_function: Callable) -> Self:
+        self.frame.tk_widget.bind(tk_event, event_function)
+
+

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Combined_Elements/Form.py

@@ -1,13 +1,7 @@
-
-from collections.abc import Iterable, Callable
-from functools import partial
-from typing import Any, Hashable, Mapping
+from typing import Any, Hashable, Mapping, Iterable, Callable
 from SwiftGUI.Compat import Self
-import json
 
-from SwiftGUI import BaseElement, Frame, Text, Input, BaseCombinedElement, Button, Event
-#from SwiftGUI.Widget_Elements.Separator import HorizontalSeparator
-from SwiftGUI.Extended_Elements.Spacer import Spacer
+from SwiftGUI import BaseElement, Text, Input, BaseCombinedElement, Button, Event, GlobalOptions, ValueDict, Spacer
 
 
 # Advanced / Combined elements
@@ -18,6 +12,8 @@ class Form(BaseCombinedElement):
     It is WIP, but I'm adding more functionality regularely
     I'll probably throw this whole class out of the window and redo it, since it is so unfathomly bad atm.
     """
+    defaults = GlobalOptions.Form
+    value: ValueDict | tuple
 
     def __init__(
             self,
@@ -27,11 +23,15 @@ class Form(BaseCombinedElement):
             key: Hashable = None,
             key_function: Callable | Iterable[Callable] = None,
             default_event: bool = None,
+            return_submits: bool = None,
             small_clear_buttons: bool = None,
             big_clear_button: bool = None,
+            clear_button_text: str = None,
             submit_button: bool = None,
+            submit_button_text: str = None,
+            space_over_buttons: int = None,
+            space_between_rows: int = None,
             #submit_key: Any = None,
-            return_submits: bool = None,
     ):
         """
 
@@ -44,10 +44,17 @@ class Form(BaseCombinedElement):
         :param big_clear_button: One big clear-button under the inputs to clear all inputs at once
         :param submit_button: True, if there should be a submit-button that throws an event when clicked. Ignores the default event
         :param return_submits: True, if pressing enter should be equal to pressing submit. Ignores the default event
+        :param clear_button_text: Text on the clear-button
+        :param submit_button_text: Text on the submit-button
+        :param space_over_buttons: Height of the separator in the row before the buttons
+        :param space_between_rows: Height of the separators between the rows
         """
-        self._has_key_mapping = isinstance(texts, Mapping)
+        space_between_rows = self.defaults.single("space_between_rows", space_between_rows)
+        space_over_buttons = self.defaults.single("space_over_buttons", space_over_buttons)
 
-        if self._has_key_mapping:
+        self._mapping_mode = isinstance(texts, Mapping)
+
+        if self._mapping_mode:
             values = list(texts.values())
         else:
             values = list(texts)
@@ -56,41 +63,51 @@ class Form(BaseCombinedElement):
 
         self._input_elements: list[Input] = list()
         self._text_elements: list[Text] = list()
+        self._small_clear_button_elements: list[Button] = list()
 
         self._small_clear_buttons = small_clear_buttons
         self._return_submits = return_submits
 
-        if self._has_key_mapping:
-            layout = [
-                *[
-                    self._make_row(k,t, text_len=_max_len) for t,k in texts.items()
-                ]
+        if self._mapping_mode:
+            rows = [
+                self._make_row(k,t, text_len=_max_len) for t,k in texts.items()
             ]
         else:
-            layout = [
-                *[
-                    self._make_row(t, text_len=_max_len) for t in values
-                ]
+            rows = [
+                self._make_row(t, text_len=_max_len) for t in values
             ]
 
+        layout = []
+        if space_between_rows:
+            for row in rows[:-1]:
+                layout.append(row)
+                layout.append([Spacer(height=space_between_rows)])
+
+            if len(rows):
+                layout.append(rows[-1])
+        else:
+            layout = rows
+
         button_row: list[BaseElement] = list()
 
-        if big_clear_button:
-            self.clear_button = Button(
-                "Clear",
-                key_function= lambda: self.clear_all_values(throw_default_event=True),
-            )
-            button_row.append(self.clear_button)
+        self.clear_button = Button(
+            self.defaults.single("clear_button_text", clear_button_text),
+            key_function= lambda: self.clear_all_values(throw_default_event=True),
+        ).set_visible(big_clear_button)
+        button_row.append(self.clear_button)
 
-        if submit_button:
-            self.submit_button = Button(
-                "Submit",
-                key_function=self.throw_event,
-            )
-            button_row.append(self.submit_button)
+        self.submit_button = Button(
+            self.defaults.single("submit_button_text", submit_button_text),
+            key_function=self.throw_event,
+        ).set_visible(submit_button)
+        button_row.append(self.submit_button)
 
-        if button_row:
-            layout.append(button_row)
+        if space_over_buttons:
+            layout.append([Spacer(height=space_over_buttons)])
+        elif space_between_rows:
+            layout.append([Spacer(height=space_between_rows)])
+
+        layout.append(button_row)
 
         super().__init__(
             layout,
@@ -102,6 +119,18 @@ class Form(BaseCombinedElement):
         if default_values is not None:
             self.set_value(default_values)
 
+    def _update_special_key(self,key:str,new_val:Any) -> bool|None:
+        match key:
+            case "clear_button_text":
+                self.clear_button.set_value(new_val)
+            case "submit_button_text":
+                self.submit_button.set_value(new_val)
+
+            case _:
+                return super()._update_special_key(key, new_val)
+
+        return True
+
     def _make_row(self, text: str, key: Hashable = None, text_len: int = 20) -> list[BaseElement]:
         """
         Create a single row of elements
@@ -128,15 +157,32 @@ class Form(BaseCombinedElement):
         ]
 
         if self._small_clear_buttons:
-            row.append(Button(
+            button = Button(
                 text= "x",
                 width=2,
                 key_function= lambda: input_elem.set_value("", throw_event=True),
                 takefocus= False,
-            ))
+            )
+            row.append(button)
+            self._small_clear_button_elements.append(button)
 
         return row
 
+    def __getitem__(self, item: Hashable | int) -> str:
+        assert self._mapping_mode or isinstance(item, int), f"{repr(self)} is created in list-mode, so only integer indexes can be used as key!"
+
+        return self.value[item]
+
+    def __setitem__(self, key: Hashable | int, value):
+        assert self._mapping_mode or isinstance(key, int), f"{repr(self)} is created in list-mode, so only integer indexes can be used as key!"
+
+        if self._mapping_mode:
+            if not key in self.v:
+                raise KeyError(f"{repr(self)} was given a key that it doesn't contain")
+            self.v[key] = value
+        else:
+            self._input_elements[key].value = value
+
     @BaseCombinedElement._run_after_window_creation
     def set_value(self, val: Iterable | Mapping) -> Self:
         """
@@ -150,7 +196,9 @@ class Form(BaseCombinedElement):
             for value, elem in zip(val, self._input_elements):
                 elem.value = value
 
-    def values(self) -> tuple:
+        return self
+
+    def as_tuple(self) -> tuple:
         """
         Return a tuple with all form-values one after the other
         :return:
@@ -158,10 +206,10 @@ class Form(BaseCombinedElement):
         return tuple(map(lambda a:a.value, self._input_elements))
 
     def _get_value(self):
-        if self._has_key_mapping:
+        if self._mapping_mode:
             return super()._get_value()
 
-        return self.values()
+        return self.as_tuple()
 
     @BaseElement._run_after_window_creation
     def update_texts(self,**kwargs) -> Self:
@@ -177,7 +225,7 @@ class Form(BaseCombinedElement):
     @BaseElement._run_after_window_creation
     def update_inputs(self,**kwargs) -> Self:
         """
-        Evoke .update on every text-element
+        Evoke .update on every input-element
         :param kwargs:
         :return:
         """
@@ -185,7 +233,18 @@ class Form(BaseCombinedElement):
             elem._update_initial(**kwargs)
         return self
 
-    def clear_all_values(self, throw_default_event: bool = False):
+    @BaseElement._run_after_window_creation
+    def update_small_clear_buttons(self,**kwargs) -> Self:
+        """
+        Evoke .update on every input-element
+        :param kwargs:
+        :return:
+        """
+        for elem in self._small_clear_button_elements:
+            elem._update_initial(**kwargs)
+        return self
+
+    def clear_all_values(self, throw_default_event: bool = False) -> Self:
         """
         Does what it says
         :return:
@@ -196,13 +255,15 @@ class Form(BaseCombinedElement):
         if throw_default_event:
             self.throw_default_event()
 
-    def set_focus(self):
+        return self
+
+    def set_focus(self) -> Self:
         """
         Focus the first row of this element
         :return:
         """
         self._input_elements[0].set_focus()
-
+        return self
 
 
 

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Examples/AllElements.py

@@ -165,7 +165,6 @@ def preview_all_elements(
             sg.Notebook(
                 sg.TabFrame([[sg.T("sg.Notebook")]], fake_key="Tab1"),
                 sg.TabFrame([[sg.T("still sg.Notebook")]], fake_key="Tab2"),
-
             )
         ],[
             sg.Spacer(height=20)
@@ -174,9 +173,9 @@ def preview_all_elements(
                 [
                     sg.T("sg.SubLayout"),
                 ],[
-                    sg.T("A seperate layout inside your layout.")
+                    sg.T("A separate layout inside your layout.")
                 ],[
-                    sg.T("It has seperate keys and its own segregated event-loop.")
+                    sg.T("It has separate keys and its own segregated event-loop.")
                 ]
             ], alignment="left"))
         ]
@@ -225,6 +224,8 @@ def preview_all_elements(
                 big_clear_button= True,
                 submit_button= True,
                 default_values= ("", "", "Click on Clear"),
+            ).update_inputs(
+                readonly=flip_readonly,
             )
         ],[
             sg.HSep()
@@ -258,7 +259,9 @@ def preview_all_elements(
             sg.T("Lets you select a day"),
         ], [
             sg.T(expand=True),
-            sg.Calendar(),
+            sg.Calendar(
+                disabled=flip_disabled,
+            ),
             sg.T(expand=True),
         ], [
             sg.HSep()
@@ -318,7 +321,7 @@ def preview_all_elements(
                                 [
                                     sg.T("sgc.Element")
                                 ],[
-                                    sg.Button("Put any sg-element onto your canvas!!")
+                                    sg.Button("Put any sg-element onto your canvas!!", disabled=flip_disabled)
                                 ]
                             ]),
                             anchor= "nw",
@@ -401,7 +404,7 @@ def preview_all_elements(
         ]
     ]
 
-    w = sg.SubWindow(layout, title="Preview of all currently available elements")
+    w = sg.SubWindow(layout, title="Preview of all currently available elements", grab_anywhere=True)
     w["List"].index = 2
     console.print("Hi, I am sg.Console!")
     console.print("I have a print-function that works just like the normal print(...)")

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Extended_Elements/Table.py

@@ -235,7 +235,9 @@ class Table(MixinElementWithDefaultEvent, BaseWidgetTTK, MixinScrollbar):
 
         self._prev_selection = all_indexes
 
-        if not all_indexes: # It's impossible for the user to cause a real event without anything selected in the table
+        if not all_indexes: # It's NEARLY impossible for the user to cause a real event without anything selected in the table
+            # The annoyance is worse without this check, so keep it!
+            # If the selectmode is extended, you can deselect rows. This is the only exception
             return
 
         self.throw_default_event()

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/GlobalOptions.py

@@ -253,9 +253,9 @@ class Text(Common, Common_Textual, Common_Background):
     justify:Literal["left","right","center"] = "left"
     #borderwidth:int = "5c" # Does not work
     apply_parent_background_color:bool = True
-
     padding:Literals.padding = 0
     width:int = None
+    relief: Literals.relief = "flat"
 
 class Scale(Common_Background, Common_Textual):
     default_value: int | float = None
@@ -409,6 +409,10 @@ class Window(Common_Background):
     hidden: bool = False
     minimized: bool = False
 
+class Tooltip(Text):
+    relief: Literals.relief = "ridge"
+    padding: Literals.padding = (10, 5)
+    text_color: Color | str = None
 
 class SubWindow(Window):
     ...
@@ -708,6 +712,12 @@ class Canvas_Image(Common_Canvas_Element, Image):
     image_height: int = None
     anchor: sg.Literals.anchor = None
 
+class Form(EMPTY):
+    clear_button_text: str = "Clear"
+    submit_button_text: str = "Submit"
+    space_over_buttons: int = 2
+    space_between_rows: int = 0
+
 def reset_all_options():
     """
     Reset everything done to the global options on runtime.

swiftgui-0.11.20/src/SwiftGUI/Popups/TooltipPopup.py

@@ -0,0 +1,41 @@
+import SwiftGUI as sg
+
+TooltipText = sg.T.with_go(sg.GlobalOptions.Tooltip)
+
+class TooltipPopup(sg.BasePopupNonblocking):
+
+    def __init__(
+            self,
+            tooltip_text: str,
+            titlebar: bool = False,
+            padx: int = 0,
+            pady: int = 0,
+            **window_kwargs,
+    ):
+        super().__init__(
+            self._create_layout(tooltip_text),
+            titlebar=titlebar,
+            padx=padx,
+            pady=pady,
+            position= self._get_position(),
+            **window_kwargs,
+        )
+
+    def _get_position(self) -> tuple[int, int]:
+        posx, posy = sg.main_window().get_mouse_position_global()
+        return posx + 15, posy
+
+    def _create_layout(self, tooltip_text: str) -> list[list[sg.BaseElement]]:
+        layout = [
+            [
+                TooltipText(    # Options of this text are defined in GlobalOptions.Tooltip
+                    tooltip_text,
+                )
+            ]
+        ]
+
+        return layout
+
+
+sg.Tooltips.set_tooltip_callable(TooltipPopup)
+

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Popups/__init__.py

@@ -3,4 +3,5 @@ from .ListPicker import list_picker
 from .SmallPopups import get_text, button_menu, yes_no, show_text
 from .VirtualKeyboard import virtual_keyboard
 from .ElementPopup import ElementPopupNonblocking, ElementPopup
+from .TooltipPopup import TooltipPopup
 

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Themes/FourColors.py

@@ -109,6 +109,9 @@ class BaseFourColors(BaseTheme):
         temp = go.Canvas_Text
         temp.color = c4
 
+        temp = go.Tooltip
+        temp.text_color = c3
+
     def get_palette_frame(self, width: int = 50, height: int = 200) -> sg.Frame:
         """
         Returns an sg.Frame that contains the 4 containing colors.

swiftgui-0.11.20/src/SwiftGUI/Tooltips.py

@@ -0,0 +1,112 @@
+import threading
+from typing import Callable, Protocol, Union
+
+import SwiftGUI as sg
+import time
+
+### YOU MAY CHANGE THESE ###
+tooltip_open_delay: float = 0.7  # How long the mouse must be still to open a tooltip
+tooltip_close_delay: float = 0.1    # Maximum delay before a tooltip closes
+
+### PLEASE DO NOT TOUCH ###
+_last_mouse_movement = 0    # When the mouse last moved
+_current_elem = None    # The sg.element the mouse is currently hovering over
+_tooltips_active: bool = False  # If the tooltip-thread is running
+_tooltip_function: Callable[[str], "SupportsClose"] | None = None # This gets called when a tooltip is opened. Must take one parameter: text
+
+class SupportsClose(Protocol):
+    def close(self):
+        ...
+
+def set_tooltip_callable(fct: Callable[[str], SupportsClose], only_if_nonexistent: bool = False):
+    """
+    Specify the function called on tooltip-opening
+    :param fct: The function to call
+    :param only_if_nonexistent: Only set that function if no function was set yet
+    :return:
+    """
+    global _tooltip_function
+
+    if only_if_nonexistent and _tooltip_function:
+        return
+
+    _tooltip_function = fct
+
+def mouse_moved_callback():
+    """Callback for the move-event"""
+    global _last_mouse_movement
+    _last_mouse_movement = time.time()
+
+def mouse_entered_elem_callback(elem):  # Can't use typehints due to circular imports
+    """
+    Mouse entered an element (key-function)
+    :param elem:
+    :return:
+    """
+    global _current_elem
+    _current_elem = elem
+
+def mouse_exited_elem_callback(elem):
+    """
+    Mouse is no longer over an element
+    :param elem:
+    :return:
+    """
+    global _current_elem
+
+    if _current_elem is elem:
+        _current_elem = None
+
+def _handle_tooltips():
+    """
+    Threaded.
+    If the mouse hasn't moved in some time, open the tooltip
+    :return:
+    """
+    global _last_mouse_movement
+    _tooltip_open = False
+    _opened_tooltip_object: Union["SupportsClose", None] = None  # The currently opened tooltip-object
+
+    while True:
+        while not _tooltip_open:
+            time_since_movement = time.time() - _last_mouse_movement
+            time_until_tooltip = tooltip_open_delay - time_since_movement
+
+            if time_until_tooltip > 0:
+                time.sleep(time_until_tooltip + 0.01)
+                continue
+
+            if _current_elem is None:
+                time.sleep(tooltip_open_delay)
+                continue
+
+            _tooltip_open = True
+
+        _last_mouse_movement = 0
+        _opened_for_this_element = _current_elem
+        _opened_tooltip_object = _tooltip_function(_current_elem.tooltip_text)  # Open tooltip
+
+        while _tooltip_open: # Tooltip open
+            time.sleep(tooltip_close_delay)
+
+            if _current_elem is not _opened_for_this_element: # If the mouse moved again
+                _tooltip_open = False
+                break
+
+        _opened_tooltip_object.close()  # Close tooltip
+        _opened_tooltip_object = None
+
+def activate_tooltips():
+    """
+    Activate the tooltip-thread if it isn't running already
+    :return:
+    """
+    global _tooltips_active
+
+    if _tooltips_active:
+        return
+
+    _tooltips_active = True
+    threading.Thread(target=_handle_tooltips, daemon=True).start()
+
+

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Button.py

@@ -214,7 +214,7 @@ class Button(MixinElementWithDefaultEvent, BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Checkbox.py

@@ -153,7 +153,7 @@ class Checkbox(MixinElementWithValue, BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Combobox.py

@@ -285,7 +285,7 @@ class Combobox(MixinElementWithValue, BaseWidgetTTK):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Frame.py

@@ -187,6 +187,9 @@ class Frame(BaseWidgetContainer):
 
         element._init(self._containing_row_elements[row_index], self.window)
 
+        if self.has_flag(ElementFlag.IS_CREATED):
+            element.init_window_creation_done()
+
         return self
 
     def get_row_index(self, elem: BaseElement) -> int | None:

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Input.py

@@ -160,7 +160,7 @@ class Input(MixinElementWithValue, BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Listbox.py

@@ -222,7 +222,7 @@ class Listbox(MixinElementWithValue, BaseWidget, MixinScrollbar):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Radiobutton.py

@@ -192,7 +192,7 @@ class Radiobutton(MixinElementWithDefaultEvent, BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Scale.py

@@ -158,7 +158,7 @@ class Scale(MixinElementWithValue, BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Spinbox.py

@@ -189,7 +189,7 @@ class Spinbox(MixinElementWithValue, BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Text.py

@@ -115,7 +115,7 @@ class Text(BaseWidget):
         self._tk_kwargs["font"] = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/TextField.py

@@ -258,7 +258,7 @@ class TextField(MixinElementWithValue, BaseWidget, MixinScrollbar):
         temp = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Widget_Elements/Treeview.py

@@ -140,7 +140,7 @@ class Treeview(BaseWidget):
         temp = font.Font(
             self.window.parent_tk_widget,
             family=self._fonttype,
-            size=self._fontsize,
+            size=self._fontsize if self._fontsize else 8,
             weight="bold" if self._bold else "normal",
             slant="italic" if self._italic else "roman",
             underline=bool(self._underline),

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/Windows.py

@@ -16,7 +16,7 @@ from PIL import Image, ImageTk
 import time
 import logging
 
-from SwiftGUI import BaseElement, Frame, ElementFlag, Literals, GlobalOptions, Color, Debug
+from SwiftGUI import BaseElement, Frame, ElementFlag, Literals, GlobalOptions, Color, Debug, Tooltips
 
 if TYPE_CHECKING:
     from SwiftGUI import AnyElement
@@ -640,6 +640,15 @@ class BaseKeyHandler(BaseElement):
         self.value.from_json(data)
         return self
 
+    def activate_tooltips(self) -> Self:
+        """
+        Activate the necessary event for tooltip-handling.
+        You don't need to call this, just ignore.
+        :return:
+        """
+        self.actual_window.activate_tooltips()
+        return self
+
 class SubLayout(BaseKeyHandler):
     """
     Can be used as an sg-element.
@@ -862,6 +871,7 @@ class Window(BaseKeyHandler):
 
         self._sg_widget:Frame = Frame(layout,alignment= self.defaults.single("alignment", alignment), expand_y=True, expand=True)
         self.root = tk.Tk()
+        self.root.withdraw()
         self.ttk_style: ttk.Style = ttk.Style(self.root)
 
         if ttk_style is None:
@@ -1425,6 +1435,22 @@ class Window(BaseKeyHandler):
 
         return x, y
 
+    ###         TOOLTIPS        ###
+    _tooltips_active: bool = False
+    def activate_tooltips(self) -> Self:
+        if self._tooltips_active:
+            return self
+
+        self.bind_event("Motion", key_function=Tooltips.mouse_moved_callback)
+        self._tooltips_active = True
+        Tooltips.activate_tooltips()
+        return self
+
+    @staticmethod
+    def _mouse_moved():
+        """Callback for the motion-event"""
+        Tooltips.mouse_moved_callback()
+
 class HiddenMainWindow(Window):
     def __init__(self):
         """
@@ -1509,7 +1535,8 @@ class SubWindow(Window):
         self._grab_anywhere = self.defaults.single("grab_anywhere", grab_anywhere)
 
         self._sg_widget:Frame = Frame(layout,alignment= self.defaults.single("alignment", alignment), expand_y=True, expand=True)
-        self.root: tk.Toplevel = tk.Toplevel()
+        self.root: tk.Toplevel = tk.Toplevel(_main_window.root)
+        self.root.withdraw()    # Todo: Stop the window from flickering when it is being created
         self.ttk_style: ttk.Style = _main_window.ttk_style
 
         if icon is None:
@@ -1535,6 +1562,7 @@ class SubWindow(Window):
         )
 
         self.init(self._sg_widget, self.root, grab_anywhere_window= self)
+        self.root.deiconify()
 
         self.bind_grab_anywhere_to_element(self._sg_widget.tk_widget)
 
@@ -1543,6 +1571,10 @@ class SubWindow(Window):
             _main_window.register_element(self)
             _main_window._value_dict.set_extra_value(key, self.value)
 
+    def init_window_creation_done(self):
+        super().init_window_creation_done()
+        self.root.deiconify()
+
     def loop_close(self, block_others: bool = True) -> tuple[Any,dict[Hashable, Any]]:
         """
         Loop until the first keyed event.

{swiftgui-0.11.19 → swiftgui-0.11.20}/src/SwiftGUI/__init__.py

@@ -85,6 +85,7 @@ Slider = Scale
 
 Combo = Combobox
 
+from . import Tooltips
 
 from .Windows import Window, BaseKeyHandler, ttk_style, main_window, SubLayout, all_decorator_key_functions, SubWindow, close_all_windows, ValueDict, call_periodically, HiddenMainWindow