SwiftGUI 0.11.19__tar.gz → 0.12.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SwiftGUI
-Version: 0.11.19
+Version: 0.12.0
 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.0/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.19 → swiftgui-0.12.0}/pyproject.toml

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

{swiftgui-0.11.19 → swiftgui-0.12.0}/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
@@ -720,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.19 → swiftgui-0.12.0}/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.12.0}/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.12.0}/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