SwiftGUI 0.11.20__tar.gz → 0.12.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SwiftGUI
-Version: 0.11.20
+Version: 0.12.1
 Summary: An easy-to-use package for quickly creating smaller and bigger GUIs
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -21,7 +21,6 @@ Description-Content-Type: text/markdown
 
 
 # SwiftGUI
-
 A python-package to easily create user-interfaces (GUIs).
 
 While most packages focus either on small, or big applications, SwiftGUI does both.
@@ -32,20 +31,20 @@ Has some minor optimizations when running in Python 3.12+.
 # Getting started / documentation
 [Start your journey here](https://github.com/CheesecakeTV/SwiftGUI-Docs/blob/main/01%20Basic%20tutorials/01%20Getting-started.md)
 
-The documentation now has [its own repository](https://github.com/CheesecakeTV/SwiftGUI-Docs).
+[Documentation](https://github.com/CheesecakeTV/SwiftGUI-Docs).
 
-# Completely vibe-coding free
+# Vibe-coding free
 No AI was used in writing this code.
 
 The only way I used it was to research really specific topics with tkinter.
 
-I did not use AI to write, check, correct, or refractor code.
-
 Even the documentation was written completely AI-free.
 Takes me around 2 hours per document, but that's a good price for keeping everything slop-free.
 
-# 35 different elements, 9 different canvas-elements
-(Version 0.11.0)
+Yes, this does slow down development quite a bit, but I trust myself to be more reliable than an AI agent.
+
+# 38 different elements, 9 different canvas-elements
+(Version 0.12.0)
 
 `import SwiftGUI as sg`
 
@@ -60,18 +59,14 @@ This applies the `Emerald`-theme, my personal favorite.
 
 See which themes are available by calling `sg.Examples.preview_all_themes()`.
 
-#  Alpha-phase!
-I am already using SwiftGUI for smaller projects and personally, like it a lot so far.
+#  Final minor version before Beta starts!
+You might have noticed that updates for SwiftGUI are rarer than they used to be.
+That's actually a good sign, it means I find less things to add/correct.
 
-However, until version 1.0.0, downward-compatability is not a priority.
-Names and functions/methods might change, which could potentially mess up your code.
+There will not be version 0.13.0, but 1.0.0 instead.
 
-For version 1.0.0, I'll sort and standardize names, so they are easier to remember.
-After version 1.0.0, there will be little to no changes that might break existing code.
-If changes can't be avoided, there will be a separate changelog which shows everything you need to
-adjust so you may update without issues.
-
-Don't worry too much though, the package is pretty much ready for beta-phase.
+I do have a couple of major tasks on my list before rolling out 1.0 though.
+Fixing the treeview for example.
 
 # Installation
 Install using pip:
@@ -79,27 +74,28 @@ Install using pip:
 pip install SwiftGUI
 ```
 
-Update SwiftGUI for the newest features and elements:
+Regularely update SwiftGUI for the newest features and bugfixes:
 ```bash
 pip install SwiftGUI -U
 ```
 
 # NOT a clone of PySimpleGUI
-SwiftGUI is it's own package with its own functionality.
+SwiftGUI is it's own package, with its own functionality.
 
 I really liked PySimpleGUI (until they went "premium"),
-but once you work a lot with it, you'll notice the downsides of it more and more.
+but once you work a lot with it, you'll notice its downsides more and more.
 
-**SwiftGUI can be used very simmilar to PySimpleGUI**, but has a lot of additional features.\
-So if you know PySimpleGUI, you won't need to start from scratch.
+The basics of SwiftGUI are almost the same as PySimpleGUI.
+So if you know PySimpleGUI, you already know many concepts of SwiftGUI.
 
-Also, there will be a lot of learning-material, including
-- Written tutorials (see "getting started" below)
-- Video tutorials (Planned for version 1.0.0)
-- Application notes, which are short descriptions of actual applications
+There is already a collection of helpful learning material, including:
+- Written tutorials (see "getting started" above)
+- Application notes, which summarize different tutorials regarding specific applications
 - Examples, which show an actual application of SwiftGUI
 - The GitHub forum ([discussions](https://github.com/CheesecakeTV/SwiftGUI/discussions)) for questions
 
+Video tutorials are planned for version 1.0.0.
+
 ## Why SwiftGUI instead of PySimpleGUI?
 I have a lot of experience with `PySimpleGUI`, used it for years.\
 It is very useful for smaller applications.
@@ -107,15 +103,20 @@ It is very useful for smaller applications.
 Unfortunately, at a certain level of complexity, you'll hit a wall.\
 All those simple features that make PySimpleGUI great, are suddenly very annoying.
 
-What annoys me the most is that PySimpleGUI forces you to use only the event-loop for functionality.
-That means, every tiny tiniest functionality needs a key and code in the event-loop.
+In the earlier versions of SwiftGUI, it was ment to "fix" annoying things in PySimpleGUI.
+For example:
+- You are forced to use the event-loop for every tiny functionality
+- You can pretty much forget about editing elements, since they are implemented so convoluded
+- Some elements throw events wrong, including sg.Table and sg.Input
 
-SwiftGUI on the other hand offers many different ways to connect layout with functionality.
-That makes it easy to "copy and paste" parts of the layout.
+Nowadays, SwiftGUI's functionality goes far beyond what PySimpleGUI has to offer.
 
-SwiftGUI also supports multiple windows much better, with every window having its own event-loop.
+The reason is simple:
+SwiftGUI is built for modularity and expandability.
+You can easily create templates, themes, custom popups, modify elements, etc.
 
-On top of that, SwiftGUI enables expandability everywhere.
-You can easily create your own elements, themes, popups and templates.
+Also, SwiftGUI works a lot better with multiple windows.
+Creating a second window is almost as simple as creating a single one.
 
+A lot more features are described/mentioned in the documentation.
 

swiftgui-0.12.1/README.md

@@ -0,0 +1,100 @@
+
+# SwiftGUI
+A python-package to easily create user-interfaces (GUIs).
+
+While most packages focus either on small, or big applications, SwiftGUI does both.
+
+## Compatible with Python 3.10 and above
+Has some minor optimizations when running in Python 3.12+.
+
+# Getting started / documentation
+[Start your journey here](https://github.com/CheesecakeTV/SwiftGUI-Docs/blob/main/01%20Basic%20tutorials/01%20Getting-started.md)
+
+[Documentation](https://github.com/CheesecakeTV/SwiftGUI-Docs).
+
+# Vibe-coding free
+No AI was used in writing this code.
+
+The only way I used it was to research really specific topics with tkinter.
+
+Even the documentation was written completely AI-free.
+Takes me around 2 hours per document, but that's a good price for keeping everything slop-free.
+
+Yes, this does slow down development quite a bit, but I trust myself to be more reliable than an AI agent.
+
+# 38 different elements, 9 different canvas-elements
+(Version 0.12.0)
+
+`import SwiftGUI as sg`
+
+Call `sg.Examples.preview_all_elements()` for an overview of all currently available elements.
+
+# Does your GUI look bad?
+`import SwiftGUI as sg`
+
+Just call `sg.Themes.FourColors.Emerald()` before creating the layout.
+
+This applies the `Emerald`-theme, my personal favorite.
+
+See which themes are available by calling `sg.Examples.preview_all_themes()`.
+
+#  Final minor version before Beta starts!
+You might have noticed that updates for SwiftGUI are rarer than they used to be.
+That's actually a good sign, it means I find less things to add/correct.
+
+There will not be version 0.13.0, but 1.0.0 instead.
+
+I do have a couple of major tasks on my list before rolling out 1.0 though.
+Fixing the treeview for example.
+
+# Installation
+Install using pip:
+```bash
+pip install SwiftGUI
+```
+
+Regularely update SwiftGUI for the newest features and bugfixes:
+```bash
+pip install SwiftGUI -U
+```
+
+# NOT a clone of PySimpleGUI
+SwiftGUI is it's own package, with its own functionality.
+
+I really liked PySimpleGUI (until they went "premium"),
+but once you work a lot with it, you'll notice its downsides more and more.
+
+The basics of SwiftGUI are almost the same as PySimpleGUI.
+So if you know PySimpleGUI, you already know many concepts of SwiftGUI.
+
+There is already a collection of helpful learning material, including:
+- Written tutorials (see "getting started" above)
+- Application notes, which summarize different tutorials regarding specific applications
+- Examples, which show an actual application of SwiftGUI
+- The GitHub forum ([discussions](https://github.com/CheesecakeTV/SwiftGUI/discussions)) for questions
+
+Video tutorials are planned for version 1.0.0.
+
+## Why SwiftGUI instead of PySimpleGUI?
+I have a lot of experience with `PySimpleGUI`, used it for years.\
+It is very useful for smaller applications.
+
+Unfortunately, at a certain level of complexity, you'll hit a wall.\
+All those simple features that make PySimpleGUI great, are suddenly very annoying.
+
+In the earlier versions of SwiftGUI, it was ment to "fix" annoying things in PySimpleGUI.
+For example:
+- You are forced to use the event-loop for every tiny functionality
+- You can pretty much forget about editing elements, since they are implemented so convoluded
+- Some elements throw events wrong, including sg.Table and sg.Input
+
+Nowadays, SwiftGUI's functionality goes far beyond what PySimpleGUI has to offer.
+
+The reason is simple:
+SwiftGUI is built for modularity and expandability.
+You can easily create templates, themes, custom popups, modify elements, etc.
+
+Also, SwiftGUI works a lot better with multiple windows.
+Creating a second window is almost as simple as creating a single one.
+
+A lot more features are described/mentioned in the documentation.

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

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

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

@@ -766,6 +766,28 @@ class BaseWidget(BaseElement):
     def __repr__(self) -> str:
         return f"<sg.{self.__class__.__name__} element with key={self.key} at {id(self)}>"
 
+    def _update_special_key(self,key:str,new_val:Any) -> bool|None:
+
+        match key:
+            case "validatecommand":
+                if new_val is None:
+                    return True
+
+                if not self.has_flag(ElementFlag.IS_CREATED):
+                    self.update_after_window_creation(validatecommand=new_val)
+                    return True
+
+                as_tuple = tuple(new_val)
+                self._tk_kwargs["validatecommand"] = (
+                    self.tk_widget.register(as_tuple[0]),
+                    *as_tuple[1:],
+                )
+
+            case _:
+                return super()._update_special_key(key, new_val)
+
+        return True
+
 class MixinScrollbar:
     """
     Base for every widget that has a scrollbar.

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

@@ -5,7 +5,7 @@ from collections.abc import Iterable
 from os import PathLike
 from typing import Literal, Union, Any, Callable
 
-from SwiftGUI import Literals, Color, font_windows, Font, Extras
+from SwiftGUI import Literals, Color, font_windows, Font, Extras, Validate
 from SwiftGUI.Utilities.Images import file_from_b64
 import SwiftGUI as sg
 
@@ -306,7 +306,7 @@ class Input(Common,Common_Textual,Common_Field_Background):
     relief: Literals.relief = None
     exportselection: bool = None
     validate: Literals.validate = None
-    validatecommand: Callable = None
+    validatecommand: Validate.BaseValidate = None
     insertbackground_color: str | Color = None
     #
     # Mixed options
@@ -544,6 +544,7 @@ class TabFrame(Frame):
 class Spinbox(Button, Input):
     default_value: float = None
     value_type: type = float
+    allow_empty: bool = True
     cursor_button: Literals.cursor = None
     background_color_button: Color | str = None
     relief_button_down: Literals.relief = None

swiftgui-0.12.1/src/SwiftGUI/Validate/Base.py

@@ -0,0 +1,119 @@
+
+class Substitutions:
+    action_code = "%d"  # 0 for deletion, 1 for insertion, -1 for focus or backend-change
+    index = "%i"        # Index where a deletion/addition was attempted. -1 if none was attempted
+    new_value = "%P"    # Value after the change, if allowed
+    old_value = "%s"    # Value before the change
+    changed_text = "%S" # The text that was inserted/deleted
+    validate = "%v"     # This element's validate option
+    callback_reason = "%V"  # The reason for this callback: 'focusin', 'focusout', 'key', or 'forced' if the text was changed from the backend
+    widget_name = "%W"  # The name of the TKINTER-widget. This is not the element-key!!!
+
+class BaseValidate:
+    substitutions: tuple[str, ...] = tuple()    # https://anzeljg.github.io/rin2/book2/2405/docs/tkinter/entry-validation.html
+
+    def __iter__(self): # Generate the tuple that is passed to the tk.widget (after registering the function) later
+        return iter((
+            self._callback,
+            *self.substitutions,
+        ))
+
+    def _callback(self, *args) -> bool:
+        """
+        Overwrite this to specify the actual validation
+        :return:
+        """
+        return True
+
+class BaseValidateValue(BaseValidate):
+    substitutions = (
+        Substitutions.new_value,
+        Substitutions.callback_reason,
+        Substitutions.old_value,
+        Substitutions.changed_text,
+        Substitutions.action_code,
+    )
+
+    def __init__(
+            self,
+            #validate_backend_change: bool = False,
+    ):
+        self._validate_backend_change = False   # This doesn't work...
+
+    def _callback(self, val: str, reason: str, val_before: str, changed_val: str, action_code: str) -> bool:
+        """
+        Gets called by tkinter.
+        All checks must pass to allow the action.
+        """
+        if (not self._validate_backend_change) and reason == "forced":
+            return True
+
+        if action_code == "0":    # Deletion
+            if not self.is_valid_deletion(val, val_before, changed_val):
+                return False
+        elif action_code == "1":  # Insertion
+            if not self.is_valid_insertion(val, val_before, changed_val):
+                return False
+
+        return self.is_valid_full_value(val)
+
+    def is_valid_full_value(self, val: str) -> bool:
+        """Called on every check with the full value after the change"""
+        return True
+
+    def is_valid_insertion(self, val: str, val_before: str, inserted_val: str) -> bool:
+        """Called when text is inserted by the user"""
+        return True
+
+    def is_valid_deletion(self, val: str, val_before: str, deleted_val: str) -> bool:
+        """Called when text is deleted by the user"""
+        return True
+
+    def __or__(self, other: "BaseValidateValue") -> "Union":
+        return Union(self, other)
+
+    def __and__(self, other: "BaseValidateValue") -> "Chain":
+        return Chain(self, other)
+
+    def __neg__(self) -> "Negate":
+        return Negate(self)
+
+class Chain(BaseValidateValue):
+
+    def __init__(self, *validators: BaseValidateValue):
+        """
+        Is valid, if ALL passed value-validators passes the value-test
+        :param validators:
+        """
+        self._validators = validators
+        super().__init__()
+
+    def _callback(self, *args) -> bool:
+        return all(map(lambda a: a._callback(*args), self._validators))
+
+
+class Union(BaseValidateValue):
+
+    def __init__(self, *validators: BaseValidateValue):
+        """
+        Is valid, if ANY passed value-validator passes the value-test
+        :param validators:
+        """
+        self._validators = validators
+        super().__init__()
+
+    def _callback(self, *args) -> bool:
+        return any(map(lambda a: a._callback(*args), self._validators))
+
+class Negate(BaseValidateValue):
+    def __init__(self, validator: BaseValidateValue):
+        """
+        Is valid, if the passed validator is not valid
+        :param validator:
+        """
+        self._validator = validator
+        super().__init__()
+
+    def _callback(self, *args) -> bool:
+        return not self._validator._callback(*args)
+

swiftgui-0.12.1/src/SwiftGUI/Validate/Common.py

@@ -0,0 +1,82 @@
+from typing import Iterable, Callable
+
+from SwiftGUI.Validate import BaseValidateValue
+
+class CanConvertTo(BaseValidateValue):
+
+    def __init__(
+            self,
+            *types: type,
+            allow_empty: bool = True,
+            exception: type[BaseException] = ValueError,
+    ):
+        """
+        Valid, if the value can be converted to ANY passed type
+        :param types: Types to convert into
+        :param allow_empty: True, if the value is allowed to be an empty string
+        :param exception: This exception will be checked. You can almost always leave it ValueError. If not, change it to Exception.
+        :param validate_backend_change:
+        """
+        self._types = types
+        self._allow_empty = allow_empty
+        self._exception = exception
+
+        super().__init__()
+
+    def is_valid_full_value(self, val: str) -> bool:
+        if self._allow_empty and not val:
+            return True
+
+        return any(map(lambda a:self._can_convert_to(val, a), self._types))
+
+    def _can_convert_to(self, val: str, this_type: type) -> bool:
+        try:
+            this_type(val)
+        except self._exception:
+            return False
+
+        return True
+
+class MaxLength(BaseValidateValue):
+
+    def __init__(self, max_len: int):
+        """
+        The value can not be longer than max_len characters
+        :param max_len:
+        """
+        self._max_len = max_len
+        super().__init__()
+
+    def is_valid_full_value(self, val: str) -> bool:
+        return len(val) <= self._max_len
+
+class ForbidDeletions(BaseValidateValue):
+    def is_valid_deletion(self, val: str, val_before: str, deleted_val: str) -> bool:
+        return False
+
+class ForbidInsertions(BaseValidateValue):
+    def is_valid_insertion(self, val: str, val_before: str, inserted_val: str) -> bool:
+        return False
+
+class WhitelistCharacters(BaseValidateValue):
+    def __init__(self, characters: Iterable[str]):
+        """
+        Forbid every character not passed.
+        Case sensitive
+        :param characters:
+        """
+        self._chars = set(characters)
+        super().__init__()
+
+    def is_valid_insertion(self, val: str, val_before: str, inserted_val: str) -> bool:
+        return all(map(lambda a:a in self._chars, inserted_val))
+
+class FullValueFunction(BaseValidateValue):
+    def __init__(self, function: Callable[[str], bool]):
+        self._fct = function
+        super().__init__()
+
+    def is_valid_full_value(self, val: str) -> bool:
+        return self._fct(val)
+
+

swiftgui-0.12.1/src/SwiftGUI/Validate/Regex.py

@@ -0,0 +1,20 @@
+import re
+from SwiftGUI.Validate import BaseValidateValue
+
+class ReFullMatch(BaseValidateValue):
+
+    def __init__(
+            self,
+            pattern: str,
+    ):
+        """
+        The full value must match the passed regex-pattern
+        :param pattern:
+        """
+        self._compiled = re.compile(pattern)
+        super().__init__()
+
+    def is_valid_full_value(self, val: str) -> bool:
+        return bool(self._compiled.fullmatch(val))
+
+

swiftgui-0.12.1/src/SwiftGUI/Validate/__init__.py

@@ -0,0 +1,4 @@
+
+from .Base import *
+from .Common import *
+from .Regex import ReFullMatch

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

@@ -4,7 +4,8 @@ from typing import Any, Iterable, Callable, Hashable
 from SwiftGUI.Base import run_after_window_creation
 from SwiftGUI.Compat import Self
 
-from SwiftGUI import GlobalOptions, BaseWidgetTTK, Literals, Color, ElementFlag, Scrollbar, MixinElementWithValue
+from SwiftGUI import GlobalOptions, BaseWidgetTTK, Literals, Color, ElementFlag, Scrollbar, MixinElementWithValue, \
+    Validate
 
 
 class Combobox(MixinElementWithValue, BaseWidgetTTK):
@@ -57,8 +58,8 @@ class Combobox(MixinElementWithValue, BaseWidgetTTK):
 
             exportselection: bool = None,
 
-            # Todo: validate,
-            #  validatecommand,
+            validate: Literals.validate = None,
+            validatecommand: Validate.BaseValidate = None,
 
             height: int = None,
             width: int = None,
@@ -155,6 +156,9 @@ class Combobox(MixinElementWithValue, BaseWidgetTTK):
             font_overstrike=font_overstrike,
 
             insertbackground = insertbackground,
+
+            validate=validate,
+            validatecommand=validatecommand,
         )
 
     @BaseWidgetTTK._run_after_window_creation

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

@@ -3,7 +3,7 @@ import tkinter.font as font
 from collections.abc import Iterable, Callable
 from typing import Literal, Any, Hashable
 
-from SwiftGUI import ElementFlag, BaseWidget, GlobalOptions, Literals, Color, MixinElementWithValue
+from SwiftGUI import ElementFlag, BaseWidget, GlobalOptions, Literals, Color, MixinElementWithValue, Validate
 from SwiftGUI.Compat import Self
 
 
@@ -61,7 +61,7 @@ class Input(MixinElementWithValue, BaseWidget):
             relief: Literals.relief = None,
             exportselection: bool = None,
             validate: Literals.validate = None,
-            validatecommand: Callable = None,
+            validatecommand: Validate.BaseValidate = None,
             #
             fonttype: str = None,
             fontsize: int = None,

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

@@ -3,7 +3,7 @@ import tkinter.font as font
 from collections.abc import Iterable, Callable
 from typing import Literal, Any, Hashable
 
-from SwiftGUI import ElementFlag, BaseWidget, GlobalOptions, Literals, Color, MixinElementWithValue
+from SwiftGUI import ElementFlag, BaseWidget, GlobalOptions, Literals, Color, MixinElementWithValue, Validate
 from SwiftGUI.Compat import Self
 
 
@@ -11,6 +11,7 @@ class Spinbox(MixinElementWithValue, BaseWidget):
     _tk_widget_class: type = tk.Spinbox # Class of the connected widget
     tk_widget: tk.Spinbox
     defaults = GlobalOptions.Spinbox   # Default values (Will be applied to kw_args-dict and passed onto the tk_widget
+    _value_type: type = str   # Set in update_initial
 
     _transfer_keys = {
         "background_color_disabled": "disabledbackground",
@@ -48,6 +49,7 @@ class Spinbox(MixinElementWithValue, BaseWidget):
 
             default_value: Any = None,
             value_type: type = None,
+            allow_empty: bool = None,
 
             cursor: Literals.cursor = None,
             cursor_button: Literals.cursor = None,
@@ -159,7 +161,7 @@ class Spinbox(MixinElementWithValue, BaseWidget):
         self._key_function = key_function
 
         self._default_val = default_value
-        self._value_type = self.defaults.single("value_type", value_type, default= float)
+        self._allow_empty = self.defaults.single("allow_empty", allow_empty, default=True)
 
         self._update_initial(cursor=cursor, cursor_button=cursor_button,
                              takefocus=takefocus, justify=justify, background_color=background_color,
@@ -178,6 +180,7 @@ class Spinbox(MixinElementWithValue, BaseWidget):
                              number_min=number_min, number_max=number_max, increment=increment, width=width,
                              repeatdelay=repeatdelay, repeatinterval=repeatinterval, state=state,
                              insertbackground_color=insertbackground_color,
+                             value_type=value_type,
                              # validate = "key",  # This restricts the user to one type of value
                              # validatecommand = (self.parent.register(self._validate), "%P"),  # This too
                              **tk_kwargs)
@@ -217,8 +220,15 @@ class Spinbox(MixinElementWithValue, BaseWidget):
             case "font_overstrike":
                 self._overstrike = self.defaults.single(key,new_val)
                 self.add_flags(ElementFlag.UPDATE_FONT)
+            case "value_type":
+                self._value_type = new_val
+                self._update_initial(
+                    validate="key",
+                    validatecommand=Validate.CanConvertTo(new_val, allow_empty=self._allow_empty),
+                )
+
             case _: # Not a match
-                return super()._update_special_key(key, new_val)
+                    return super()._update_special_key(key, new_val)
 
         return True
 
@@ -242,16 +252,16 @@ class Spinbox(MixinElementWithValue, BaseWidget):
         except tk.TclError:  # _tk_target_value isn't used
             pass
 
-        return self._value_type(self._last_viable_value)
+        if not self._last_viable_value:
+            return self._value_type()
 
-    def _validate(self, val: Any) -> bool:
-        try:
-            self._value_type(val)
-            return True
-        except (ValueError, TypeError):
-            return False
+        return self._value_type(self._last_viable_value)
 
     def set_value(self,val:Any) -> Self:
+        if self._allow_empty and not val:
+            self._prev_value = self._value_type()
+            return super().set_value(self._prev_value)
+
         try:
             # Try to convert and manually apply the new value
             self._prev_value = self._value_type(val)
@@ -263,10 +273,5 @@ class Spinbox(MixinElementWithValue, BaseWidget):
     def init_window_creation_done(self):
         super().init_window_creation_done()
 
-        self._update_initial(
-            validate= "key",
-            validatecommand = (self.tk_widget.register(self._validate), "%P")
-        )
-
         if self._default_val is not None:
             self._tk_target_value.set(self._default_val)

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

@@ -274,6 +274,13 @@ class TextField(MixinElementWithValue, BaseWidget, MixinScrollbar):
 
     @_forced_value_change
     def set_value(self, val:Any):
+        # Todo: For some reason, this function is called twice on updates.
+        #  This should be investigated further.
+        #  The second call can be None, which is why the None-check below is necessary atm.
+
+        if val is None:
+            return
+
         self._apply_value(val)
         self.tk_widget.delete("1.0","end")
         self.tk_widget.insert("1.0",val)

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

@@ -6,6 +6,8 @@ logger.debug("Beginning to load SwiftGUI")
 loaded_addons: set[str] = set() # Contains all included SwiftGUI-addons.
 # If you'd like your own addon officially included, create an issue on GitHub.
 
+from . import Validate
+
 from .Exceptions import *
 
 from . import Extras

swiftgui-0.11.20/README.md

@@ -1,99 +0,0 @@
-
-# SwiftGUI
-
-A python-package to easily create user-interfaces (GUIs).
-
-While most packages focus either on small, or big applications, SwiftGUI does both.
-
-## Compatible with Python 3.10 and above
-Has some minor optimizations when running in Python 3.12+.
-
-# Getting started / documentation
-[Start your journey here](https://github.com/CheesecakeTV/SwiftGUI-Docs/blob/main/01%20Basic%20tutorials/01%20Getting-started.md)
-
-The documentation now has [its own repository](https://github.com/CheesecakeTV/SwiftGUI-Docs).
-
-# Completely vibe-coding free
-No AI was used in writing this code.
-
-The only way I used it was to research really specific topics with tkinter.
-
-I did not use AI to write, check, correct, or refractor code.
-
-Even the documentation was written completely AI-free.
-Takes me around 2 hours per document, but that's a good price for keeping everything slop-free.
-
-# 35 different elements, 9 different canvas-elements
-(Version 0.11.0)
-
-`import SwiftGUI as sg`
-
-Call `sg.Examples.preview_all_elements()` for an overview of all currently available elements.
-
-# Does your GUI look bad?
-`import SwiftGUI as sg`
-
-Just call `sg.Themes.FourColors.Emerald()` before creating the layout.
-
-This applies the `Emerald`-theme, my personal favorite.
-
-See which themes are available by calling `sg.Examples.preview_all_themes()`.
-
-#  Alpha-phase!
-I am already using SwiftGUI for smaller projects and personally, like it a lot so far.
-
-However, until version 1.0.0, downward-compatability is not a priority.
-Names and functions/methods might change, which could potentially mess up your code.
-
-For version 1.0.0, I'll sort and standardize names, so they are easier to remember.
-After version 1.0.0, there will be little to no changes that might break existing code.
-If changes can't be avoided, there will be a separate changelog which shows everything you need to
-adjust so you may update without issues.
-
-Don't worry too much though, the package is pretty much ready for beta-phase.
-
-# Installation
-Install using pip:
-```bash
-pip install SwiftGUI
-```
-
-Update SwiftGUI for the newest features and elements:
-```bash
-pip install SwiftGUI -U
-```
-
-# NOT a clone of PySimpleGUI
-SwiftGUI is it's own package with its own functionality.
-
-I really liked PySimpleGUI (until they went "premium"),
-but once you work a lot with it, you'll notice the downsides of it more and more.
-
-**SwiftGUI can be used very simmilar to PySimpleGUI**, but has a lot of additional features.\
-So if you know PySimpleGUI, you won't need to start from scratch.
-
-Also, there will be a lot of learning-material, including
-- Written tutorials (see "getting started" below)
-- Video tutorials (Planned for version 1.0.0)
-- Application notes, which are short descriptions of actual applications
-- Examples, which show an actual application of SwiftGUI
-- The GitHub forum ([discussions](https://github.com/CheesecakeTV/SwiftGUI/discussions)) for questions
-
-## Why SwiftGUI instead of PySimpleGUI?
-I have a lot of experience with `PySimpleGUI`, used it for years.\
-It is very useful for smaller applications.
-
-Unfortunately, at a certain level of complexity, you'll hit a wall.\
-All those simple features that make PySimpleGUI great, are suddenly very annoying.
-
-What annoys me the most is that PySimpleGUI forces you to use only the event-loop for functionality.
-That means, every tiny tiniest functionality needs a key and code in the event-loop.
-
-SwiftGUI on the other hand offers many different ways to connect layout with functionality.
-That makes it easy to "copy and paste" parts of the layout.
-
-SwiftGUI also supports multiple windows much better, with every window having its own event-loop.
-
-On top of that, SwiftGUI enables expandability everywhere.
-You can easily create your own elements, themes, popups and templates.
-